]> 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 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3934 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3935 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3936 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3937 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3938 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3940 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3941 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3942 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3943 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3944 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3945 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3946 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3947 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3948 static const wxString wxPyControlNameStr(wxControlNameStr);
3949 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3950 if (clientData) {
3951 wxPyClientData* data = new wxPyClientData(clientData);
3952 return self->Append(item, data);
3953 } else
3954 return self->Append(item);
3955 }
3956 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3957 if (clientData) {
3958 wxPyClientData* data = new wxPyClientData(clientData);
3959 return self->Insert(item, pos, data);
3960 } else
3961 return self->Insert(item, pos);
3962 }
3963 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3964 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3965 if (data) {
3966 Py_INCREF(data->m_obj);
3967 return data->m_obj;
3968 } else {
3969 Py_INCREF(Py_None);
3970 return Py_None;
3971 }
3972 }
3973 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3974 wxPyClientData* data = new wxPyClientData(clientData);
3975 self->SetClientObject(n, data);
3976 }
3977
3978
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3980 wxPyUserData* data = NULL;
3981 if ( userData ) {
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 data = new wxPyUserData(userData);
3984 wxPyEndBlockThreads(blocked);
3985 }
3986 return new wxSizerItem(window, proportion, flag, border, data);
3987 }
3988 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 return new wxSizerItem(width, height, proportion, flag, border, data);
3996 }
3997 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3998 wxPyUserData* data = NULL;
3999 if ( userData ) {
4000 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4001 data = new wxPyUserData(userData);
4002 wxPyEndBlockThreads(blocked);
4003 }
4004 return new wxSizerItem(sizer, proportion, flag, border, data);
4005 }
4006
4007 SWIGINTERNINLINE PyObject *
4008 SWIG_From_float (float value)
4009 {
4010 return SWIG_From_double (value);
4011 }
4012
4013 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4014 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 self->SetUserData(data);
4031 }
4032
4033 // Figure out the type of the sizer item
4034
4035 struct wxPySizerItemInfo {
4036 wxPySizerItemInfo()
4037 : window(NULL), sizer(NULL), gotSize(false),
4038 size(wxDefaultSize), gotPos(false), pos(-1)
4039 {}
4040
4041 wxWindow* window;
4042 wxSizer* sizer;
4043 bool gotSize;
4044 wxSize size;
4045 bool gotPos;
4046 int pos;
4047 };
4048
4049 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4050
4051 wxPySizerItemInfo info;
4052 wxSize size;
4053 wxSize* sizePtr = &size;
4054
4055 // Find out what the type of the item is
4056 // try wxWindow
4057 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4058 PyErr_Clear();
4059 info.window = NULL;
4060
4061 // try wxSizer
4062 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4063 PyErr_Clear();
4064 info.sizer = NULL;
4065
4066 // try wxSize or (w,h)
4067 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4068 info.size = *sizePtr;
4069 info.gotSize = true;
4070 }
4071
4072 // or a single int
4073 if (checkIdx && PyInt_Check(item)) {
4074 info.pos = PyInt_AsLong(item);
4075 info.gotPos = true;
4076 }
4077 }
4078 }
4079
4080 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4081 // no expected type, figure out what kind of error message to generate
4082 if ( !checkSize && !checkIdx )
4083 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4084 else if ( checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4086 else if ( !checkSize && checkIdx)
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4088 else
4089 // can this one happen?
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4091 }
4092
4093 return info;
4094 }
4095
4096 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4097 if (!self->GetClientObject())
4098 self->SetClientObject(new wxPyOORClientData(_self));
4099 }
4100 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4101
4102 wxPyUserData* data = NULL;
4103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4105 if ( userData && (info.window || info.sizer || info.gotSize) )
4106 data = new wxPyUserData(userData);
4107 if ( info.sizer )
4108 PyObject_SetAttrString(item,"thisown",Py_False);
4109 wxPyEndBlockThreads(blocked);
4110
4111 // Now call the real Add method if a valid item type was found
4112 if ( info.window )
4113 return self->Add(info.window, proportion, flag, border, data);
4114 else if ( info.sizer )
4115 return self->Add(info.sizer, proportion, flag, border, data);
4116 else if (info.gotSize)
4117 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4118 proportion, flag, border, data);
4119 else
4120 return NULL;
4121 }
4122 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4123
4124 wxPyUserData* data = NULL;
4125 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4126 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4127 if ( userData && (info.window || info.sizer || info.gotSize) )
4128 data = new wxPyUserData(userData);
4129 if ( info.sizer )
4130 PyObject_SetAttrString(item,"thisown",Py_False);
4131 wxPyEndBlockThreads(blocked);
4132
4133 // Now call the real Insert method if a valid item type was found
4134 if ( info.window )
4135 return self->Insert(before, info.window, proportion, flag, border, data);
4136 else if ( info.sizer )
4137 return self->Insert(before, info.sizer, proportion, flag, border, data);
4138 else if (info.gotSize)
4139 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4140 proportion, flag, border, data);
4141 else
4142 return NULL;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Prepend method if a valid item type was found
4156 if ( info.window )
4157 return self->Prepend(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Prepend(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Remove(info.window);
4172 else if ( info.sizer )
4173 return self->Remove(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Remove(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->Detach(info.window);
4185 else if ( info.sizer )
4186 return self->Detach(info.sizer);
4187 else if ( info.gotPos )
4188 return self->Detach(info.pos);
4189 else
4190 return false;
4191 }
4192 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 return self->GetItem(info.window);
4198 else if ( info.sizer )
4199 return self->GetItem(info.sizer);
4200 else if ( info.gotPos )
4201 return self->GetItem(info.pos);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 self->SetItemMinSize(info.window, size);
4211 else if ( info.sizer )
4212 self->SetItemMinSize(info.sizer, size);
4213 else if ( info.gotPos )
4214 self->SetItemMinSize(info.pos, size);
4215 }
4216 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4217 wxSizerItemList& list = self->GetChildren();
4218 return wxPy_ConvertList(&list);
4219 }
4220 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Show(info.window, show, recursive);
4226 else if ( info.sizer )
4227 return self->Show(info.sizer, show, recursive);
4228 else if ( info.gotPos )
4229 return self->Show(info.pos, show);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->IsShown(info.window);
4239 else if ( info.sizer )
4240 return self->IsShown(info.sizer);
4241 else if ( info.gotPos )
4242 return self->IsShown(info.pos);
4243 else
4244 return false;
4245 }
4246
4247 // See pyclasses.h
4248 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4249 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4250 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4251
4252
4253
4254
4255 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4256 {
4257 if (source == Py_None) {
4258 **obj = wxGBPosition(-1,-1);
4259 return true;
4260 }
4261 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4262 }
4263
4264 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4265 {
4266 if (source == Py_None) {
4267 **obj = wxGBSpan(-1,-1);
4268 return true;
4269 }
4270 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4271 }
4272
4273
4274 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4275 wxGBPosition temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBPosition_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4284 wxGBPosition temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBPosition_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4293 self->SetRow(row);
4294 self->SetCol(col);
4295 }
4296 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4305 wxGBSpan temp, *obj = &temp;
4306 if ( other == Py_None ) return false;
4307 if ( ! wxGBSpan_helper(other, &obj) ) {
4308 PyErr_Clear();
4309 return false;
4310 }
4311 return self->operator==(*obj);
4312 }
4313 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4314 wxGBSpan temp, *obj = &temp;
4315 if ( other == Py_None ) return true;
4316 if ( ! wxGBSpan_helper(other, &obj)) {
4317 PyErr_Clear();
4318 return true;
4319 }
4320 return self->operator!=(*obj);
4321 }
4322 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4323 self->SetRowspan(rowspan);
4324 self->SetColspan(colspan);
4325 }
4326 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 PyObject* tup = PyTuple_New(2);
4329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4331 wxPyEndBlockThreads(blocked);
4332 return tup;
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4335 wxPyUserData* data = NULL;
4336 if ( userData ) {
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 data = new wxPyUserData(userData);
4339 wxPyEndBlockThreads(blocked);
4340 }
4341 return new wxGBSizerItem(window, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4344 wxPyUserData* data = NULL;
4345 if ( userData ) {
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 data = new wxPyUserData(userData);
4348 wxPyEndBlockThreads(blocked);
4349 }
4350 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4351 }
4352 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4353 wxPyUserData* data = NULL;
4354 if ( userData ) {
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 data = new wxPyUserData(userData);
4357 wxPyEndBlockThreads(blocked);
4358 }
4359 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4360 }
4361 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4362 int row, col;
4363 self->GetEndPos(row, col);
4364 return wxGBPosition(row, col);
4365 }
4366 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4367
4368 wxPyUserData* data = NULL;
4369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4370 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4371 if ( userData && (info.window || info.sizer || info.gotSize) )
4372 data = new wxPyUserData(userData);
4373 if ( info.sizer )
4374 PyObject_SetAttrString(item,"thisown",Py_False);
4375 wxPyEndBlockThreads(blocked);
4376
4377 // Now call the real Add method if a valid item type was found
4378 if ( info.window )
4379 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4380 else if ( info.sizer )
4381 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4382 else if (info.gotSize)
4383 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4384 pos, span, flag, border, data);
4385 return NULL;
4386 }
4387
4388
4389 #ifdef __cplusplus
4390 extern "C" {
4391 #endif
4392 SWIGINTERN int EmptyString_set(PyObject *) {
4393 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4394 return 1;
4395 }
4396
4397
4398 SWIGINTERN PyObject *EmptyString_get(void) {
4399 PyObject *pyobj = 0;
4400
4401 {
4402 #if wxUSE_UNICODE
4403 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4404 #else
4405 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #endif
4407 }
4408 return pyobj;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 wxString result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = wxObject_GetClassName(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 {
4434 #if wxUSE_UNICODE
4435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4436 #else
4437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4438 #endif
4439 }
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxObject *arg1 = (wxObject *) 0 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 PyObject *swig_obj[1] ;
4452
4453 if (!args) SWIG_fail;
4454 swig_obj[0] = args;
4455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4458 }
4459 arg1 = reinterpret_cast< wxObject * >(argp1);
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 wxObject_Destroy(arg1);
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_Py_Void();
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4474 PyObject *obj;
4475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4476 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4477 return SWIG_Py_Void();
4478 }
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int arg2 ;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 int val2 ;
4487 int ecode2 = 0 ;
4488 PyObject *swig_obj[2] ;
4489
4490 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4497 if (!SWIG_IsOK(ecode2)) {
4498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4499 }
4500 arg2 = static_cast< int >(val2);
4501 if (arg1) (arg1)->x = arg2;
4502
4503 resultobj = SWIG_Py_Void();
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int result;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 PyObject *swig_obj[1] ;
4517
4518 if (!args) SWIG_fail;
4519 swig_obj[0] = args;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 result = (int) ((arg1)->x);
4526 resultobj = SWIG_From_int(static_cast< int >(result));
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int arg2 ;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 int val2 ;
4540 int ecode2 = 0 ;
4541 PyObject *swig_obj[2] ;
4542
4543 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4550 if (!SWIG_IsOK(ecode2)) {
4551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4552 }
4553 arg2 = static_cast< int >(val2);
4554 if (arg1) (arg1)->y = arg2;
4555
4556 resultobj = SWIG_Py_Void();
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *resultobj = 0;
4565 wxSize *arg1 = (wxSize *) 0 ;
4566 int result;
4567 void *argp1 = 0 ;
4568 int res1 = 0 ;
4569 PyObject *swig_obj[1] ;
4570
4571 if (!args) SWIG_fail;
4572 swig_obj[0] = args;
4573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4576 }
4577 arg1 = reinterpret_cast< wxSize * >(argp1);
4578 result = (int) ((arg1)->y);
4579 resultobj = SWIG_From_int(static_cast< int >(result));
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj = 0;
4588 int arg1 = (int) 0 ;
4589 int arg2 = (int) 0 ;
4590 wxSize *result = 0 ;
4591 int val1 ;
4592 int ecode1 = 0 ;
4593 int val2 ;
4594 int ecode2 = 0 ;
4595 PyObject * obj0 = 0 ;
4596 PyObject * obj1 = 0 ;
4597 char * kwnames[] = {
4598 (char *) "w",(char *) "h", NULL
4599 };
4600
4601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4602 if (obj0) {
4603 ecode1 = SWIG_AsVal_int(obj0, &val1);
4604 if (!SWIG_IsOK(ecode1)) {
4605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4606 }
4607 arg1 = static_cast< int >(val1);
4608 }
4609 if (obj1) {
4610 ecode2 = SWIG_AsVal_int(obj1, &val2);
4611 if (!SWIG_IsOK(ecode2)) {
4612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4613 }
4614 arg2 = static_cast< int >(val2);
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (wxSize *)new wxSize(arg1,arg2);
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 PyObject *resultobj = 0;
4631 wxSize *arg1 = (wxSize *) 0 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject *swig_obj[1] ;
4635
4636 if (!args) SWIG_fail;
4637 swig_obj[0] = args;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 delete arg1;
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___eq__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 PyObject *arg2 = (PyObject *) 0 ;
4694 bool result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "other", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 arg2 = obj1;
4710 {
4711 result = (bool)wxSize___ne__(arg1,arg2);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 wxSize *arg1 = (wxSize *) 0 ;
4726 wxSize *arg2 = 0 ;
4727 wxSize result;
4728 void *argp1 = 0 ;
4729 int res1 = 0 ;
4730 wxSize temp2 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char * kwnames[] = {
4734 (char *) "self",(char *) "sz", NULL
4735 };
4736
4737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4739 if (!SWIG_IsOK(res1)) {
4740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4741 }
4742 arg1 = reinterpret_cast< wxSize * >(argp1);
4743 {
4744 arg2 = &temp2;
4745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (arg1)->operator +((wxSize const &)*arg2);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 wxSize *arg2 = 0 ;
4764 wxSize result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 wxSize temp2 ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 char * kwnames[] = {
4771 (char *) "self",(char *) "sz", NULL
4772 };
4773
4774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4776 if (!SWIG_IsOK(res1)) {
4777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4778 }
4779 arg1 = reinterpret_cast< wxSize * >(argp1);
4780 {
4781 arg2 = &temp2;
4782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 result = (arg1)->operator -((wxSize const &)*arg2);
4787 wxPyEndAllowThreads(__tstate);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 wxSize *arg2 = 0 ;
4801 void *argp1 = 0 ;
4802 int res1 = 0 ;
4803 wxSize temp2 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char * kwnames[] = {
4807 (char *) "self",(char *) "sz", NULL
4808 };
4809
4810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4812 if (!SWIG_IsOK(res1)) {
4813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4814 }
4815 arg1 = reinterpret_cast< wxSize * >(argp1);
4816 {
4817 arg2 = &temp2;
4818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 (arg1)->IncTo((wxSize const &)*arg2);
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_Py_Void();
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 wxSize *arg2 = 0 ;
4837 void *argp1 = 0 ;
4838 int res1 = 0 ;
4839 wxSize temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "sz", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 (arg1)->DecTo((wxSize const &)*arg2);
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_Py_Void();
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = 0;
4871 wxSize *arg1 = (wxSize *) 0 ;
4872 int arg2 ;
4873 int arg3 ;
4874 void *argp1 = 0 ;
4875 int res1 = 0 ;
4876 int val2 ;
4877 int ecode2 = 0 ;
4878 int val3 ;
4879 int ecode3 = 0 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 PyObject * obj2 = 0 ;
4883 char * kwnames[] = {
4884 (char *) "self",(char *) "dx",(char *) "dy", NULL
4885 };
4886
4887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4889 if (!SWIG_IsOK(res1)) {
4890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4891 }
4892 arg1 = reinterpret_cast< wxSize * >(argp1);
4893 ecode2 = SWIG_AsVal_int(obj1, &val2);
4894 if (!SWIG_IsOK(ecode2)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4896 }
4897 arg2 = static_cast< int >(val2);
4898 ecode3 = SWIG_AsVal_int(obj2, &val3);
4899 if (!SWIG_IsOK(ecode3)) {
4900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4901 }
4902 arg3 = static_cast< int >(val3);
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 (arg1)->IncBy(arg2,arg3);
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_Py_Void();
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 int arg2 ;
4920 int arg3 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 int val2 ;
4924 int ecode2 = 0 ;
4925 int val3 ;
4926 int ecode3 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 PyObject * obj2 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "self",(char *) "dx",(char *) "dy", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4936 if (!SWIG_IsOK(res1)) {
4937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4938 }
4939 arg1 = reinterpret_cast< wxSize * >(argp1);
4940 ecode2 = SWIG_AsVal_int(obj1, &val2);
4941 if (!SWIG_IsOK(ecode2)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4943 }
4944 arg2 = static_cast< int >(val2);
4945 ecode3 = SWIG_AsVal_int(obj2, &val3);
4946 if (!SWIG_IsOK(ecode3)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4948 }
4949 arg3 = static_cast< int >(val3);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->DecBy(arg2,arg3);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 float arg2 ;
4967 float arg3 ;
4968 void *argp1 = 0 ;
4969 int res1 = 0 ;
4970 float val2 ;
4971 int ecode2 = 0 ;
4972 float val3 ;
4973 int ecode3 = 0 ;
4974 PyObject * obj0 = 0 ;
4975 PyObject * obj1 = 0 ;
4976 PyObject * obj2 = 0 ;
4977 char * kwnames[] = {
4978 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4979 };
4980
4981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4983 if (!SWIG_IsOK(res1)) {
4984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4985 }
4986 arg1 = reinterpret_cast< wxSize * >(argp1);
4987 ecode2 = SWIG_AsVal_float(obj1, &val2);
4988 if (!SWIG_IsOK(ecode2)) {
4989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4990 }
4991 arg2 = static_cast< float >(val2);
4992 ecode3 = SWIG_AsVal_float(obj2, &val3);
4993 if (!SWIG_IsOK(ecode3)) {
4994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4995 }
4996 arg3 = static_cast< float >(val3);
4997 {
4998 PyThreadState* __tstate = wxPyBeginAllowThreads();
4999 (arg1)->Scale(arg2,arg3);
5000 wxPyEndAllowThreads(__tstate);
5001 if (PyErr_Occurred()) SWIG_fail;
5002 }
5003 resultobj = SWIG_Py_Void();
5004 return resultobj;
5005 fail:
5006 return NULL;
5007 }
5008
5009
5010 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5011 PyObject *resultobj = 0;
5012 wxSize *arg1 = (wxSize *) 0 ;
5013 int arg2 ;
5014 int arg3 ;
5015 void *argp1 = 0 ;
5016 int res1 = 0 ;
5017 int val2 ;
5018 int ecode2 = 0 ;
5019 int val3 ;
5020 int ecode3 = 0 ;
5021 PyObject * obj0 = 0 ;
5022 PyObject * obj1 = 0 ;
5023 PyObject * obj2 = 0 ;
5024 char * kwnames[] = {
5025 (char *) "self",(char *) "w",(char *) "h", NULL
5026 };
5027
5028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5030 if (!SWIG_IsOK(res1)) {
5031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5032 }
5033 arg1 = reinterpret_cast< wxSize * >(argp1);
5034 ecode2 = SWIG_AsVal_int(obj1, &val2);
5035 if (!SWIG_IsOK(ecode2)) {
5036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5037 }
5038 arg2 = static_cast< int >(val2);
5039 ecode3 = SWIG_AsVal_int(obj2, &val3);
5040 if (!SWIG_IsOK(ecode3)) {
5041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5042 }
5043 arg3 = static_cast< int >(val3);
5044 {
5045 PyThreadState* __tstate = wxPyBeginAllowThreads();
5046 (arg1)->Set(arg2,arg3);
5047 wxPyEndAllowThreads(__tstate);
5048 if (PyErr_Occurred()) SWIG_fail;
5049 }
5050 resultobj = SWIG_Py_Void();
5051 return resultobj;
5052 fail:
5053 return NULL;
5054 }
5055
5056
5057 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5058 PyObject *resultobj = 0;
5059 wxSize *arg1 = (wxSize *) 0 ;
5060 int arg2 ;
5061 void *argp1 = 0 ;
5062 int res1 = 0 ;
5063 int val2 ;
5064 int ecode2 = 0 ;
5065 PyObject * obj0 = 0 ;
5066 PyObject * obj1 = 0 ;
5067 char * kwnames[] = {
5068 (char *) "self",(char *) "w", NULL
5069 };
5070
5071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5073 if (!SWIG_IsOK(res1)) {
5074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5075 }
5076 arg1 = reinterpret_cast< wxSize * >(argp1);
5077 ecode2 = SWIG_AsVal_int(obj1, &val2);
5078 if (!SWIG_IsOK(ecode2)) {
5079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5080 }
5081 arg2 = static_cast< int >(val2);
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 (arg1)->SetWidth(arg2);
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = SWIG_Py_Void();
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5096 PyObject *resultobj = 0;
5097 wxSize *arg1 = (wxSize *) 0 ;
5098 int arg2 ;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 int val2 ;
5102 int ecode2 = 0 ;
5103 PyObject * obj0 = 0 ;
5104 PyObject * obj1 = 0 ;
5105 char * kwnames[] = {
5106 (char *) "self",(char *) "h", NULL
5107 };
5108
5109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5111 if (!SWIG_IsOK(res1)) {
5112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5113 }
5114 arg1 = reinterpret_cast< wxSize * >(argp1);
5115 ecode2 = SWIG_AsVal_int(obj1, &val2);
5116 if (!SWIG_IsOK(ecode2)) {
5117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5118 }
5119 arg2 = static_cast< int >(val2);
5120 {
5121 PyThreadState* __tstate = wxPyBeginAllowThreads();
5122 (arg1)->SetHeight(arg2);
5123 wxPyEndAllowThreads(__tstate);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 resultobj = SWIG_Py_Void();
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5134 PyObject *resultobj = 0;
5135 wxSize *arg1 = (wxSize *) 0 ;
5136 int result;
5137 void *argp1 = 0 ;
5138 int res1 = 0 ;
5139 PyObject *swig_obj[1] ;
5140
5141 if (!args) SWIG_fail;
5142 swig_obj[0] = args;
5143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5144 if (!SWIG_IsOK(res1)) {
5145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5146 }
5147 arg1 = reinterpret_cast< wxSize * >(argp1);
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 result = (int)((wxSize const *)arg1)->GetWidth();
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_From_int(static_cast< int >(result));
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 int result;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 PyObject *swig_obj[1] ;
5168
5169 if (!args) SWIG_fail;
5170 swig_obj[0] = args;
5171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5174 }
5175 arg1 = reinterpret_cast< wxSize * >(argp1);
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 result = (int)((wxSize const *)arg1)->GetHeight();
5179 wxPyEndAllowThreads(__tstate);
5180 if (PyErr_Occurred()) SWIG_fail;
5181 }
5182 resultobj = SWIG_From_int(static_cast< int >(result));
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5190 PyObject *resultobj = 0;
5191 wxSize *arg1 = (wxSize *) 0 ;
5192 bool result;
5193 void *argp1 = 0 ;
5194 int res1 = 0 ;
5195 PyObject *swig_obj[1] ;
5196
5197 if (!args) SWIG_fail;
5198 swig_obj[0] = args;
5199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5200 if (!SWIG_IsOK(res1)) {
5201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5202 }
5203 arg1 = reinterpret_cast< wxSize * >(argp1);
5204 {
5205 PyThreadState* __tstate = wxPyBeginAllowThreads();
5206 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5207 wxPyEndAllowThreads(__tstate);
5208 if (PyErr_Occurred()) SWIG_fail;
5209 }
5210 {
5211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5212 }
5213 return resultobj;
5214 fail:
5215 return NULL;
5216 }
5217
5218
5219 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5220 PyObject *resultobj = 0;
5221 wxSize *arg1 = (wxSize *) 0 ;
5222 wxSize *arg2 = 0 ;
5223 void *argp1 = 0 ;
5224 int res1 = 0 ;
5225 wxSize temp2 ;
5226 PyObject * obj0 = 0 ;
5227 PyObject * obj1 = 0 ;
5228 char * kwnames[] = {
5229 (char *) "self",(char *) "size", NULL
5230 };
5231
5232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5234 if (!SWIG_IsOK(res1)) {
5235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5236 }
5237 arg1 = reinterpret_cast< wxSize * >(argp1);
5238 {
5239 arg2 = &temp2;
5240 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5241 }
5242 {
5243 PyThreadState* __tstate = wxPyBeginAllowThreads();
5244 (arg1)->SetDefaults((wxSize const &)*arg2);
5245 wxPyEndAllowThreads(__tstate);
5246 if (PyErr_Occurred()) SWIG_fail;
5247 }
5248 resultobj = SWIG_Py_Void();
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5256 PyObject *resultobj = 0;
5257 wxSize *arg1 = (wxSize *) 0 ;
5258 PyObject *result = 0 ;
5259 void *argp1 = 0 ;
5260 int res1 = 0 ;
5261 PyObject *swig_obj[1] ;
5262
5263 if (!args) SWIG_fail;
5264 swig_obj[0] = args;
5265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5266 if (!SWIG_IsOK(res1)) {
5267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5268 }
5269 arg1 = reinterpret_cast< wxSize * >(argp1);
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = (PyObject *)wxSize_Get(arg1);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = result;
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 PyObject *obj;
5285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5286 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5287 return SWIG_Py_Void();
5288 }
5289
5290 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5291 return SWIG_Python_InitShadowInstance(args);
5292 }
5293
5294 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5295 PyObject *resultobj = 0;
5296 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5297 double arg2 ;
5298 void *argp1 = 0 ;
5299 int res1 = 0 ;
5300 double val2 ;
5301 int ecode2 = 0 ;
5302 PyObject *swig_obj[2] ;
5303
5304 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5306 if (!SWIG_IsOK(res1)) {
5307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5308 }
5309 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5310 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5311 if (!SWIG_IsOK(ecode2)) {
5312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5313 }
5314 arg2 = static_cast< double >(val2);
5315 if (arg1) (arg1)->x = arg2;
5316
5317 resultobj = SWIG_Py_Void();
5318 return resultobj;
5319 fail:
5320 return NULL;
5321 }
5322
5323
5324 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5325 PyObject *resultobj = 0;
5326 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5327 double result;
5328 void *argp1 = 0 ;
5329 int res1 = 0 ;
5330 PyObject *swig_obj[1] ;
5331
5332 if (!args) SWIG_fail;
5333 swig_obj[0] = args;
5334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5335 if (!SWIG_IsOK(res1)) {
5336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5337 }
5338 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5339 result = (double) ((arg1)->x);
5340 resultobj = SWIG_From_double(static_cast< double >(result));
5341 return resultobj;
5342 fail:
5343 return NULL;
5344 }
5345
5346
5347 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5348 PyObject *resultobj = 0;
5349 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5350 double arg2 ;
5351 void *argp1 = 0 ;
5352 int res1 = 0 ;
5353 double val2 ;
5354 int ecode2 = 0 ;
5355 PyObject *swig_obj[2] ;
5356
5357 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5359 if (!SWIG_IsOK(res1)) {
5360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5361 }
5362 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5363 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5364 if (!SWIG_IsOK(ecode2)) {
5365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5366 }
5367 arg2 = static_cast< double >(val2);
5368 if (arg1) (arg1)->y = arg2;
5369
5370 resultobj = SWIG_Py_Void();
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5378 PyObject *resultobj = 0;
5379 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5380 double result;
5381 void *argp1 = 0 ;
5382 int res1 = 0 ;
5383 PyObject *swig_obj[1] ;
5384
5385 if (!args) SWIG_fail;
5386 swig_obj[0] = args;
5387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5388 if (!SWIG_IsOK(res1)) {
5389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5390 }
5391 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5392 result = (double) ((arg1)->y);
5393 resultobj = SWIG_From_double(static_cast< double >(result));
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5401 PyObject *resultobj = 0;
5402 double arg1 = (double) 0.0 ;
5403 double arg2 = (double) 0.0 ;
5404 wxRealPoint *result = 0 ;
5405 double val1 ;
5406 int ecode1 = 0 ;
5407 double val2 ;
5408 int ecode2 = 0 ;
5409 PyObject * obj0 = 0 ;
5410 PyObject * obj1 = 0 ;
5411 char * kwnames[] = {
5412 (char *) "x",(char *) "y", NULL
5413 };
5414
5415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5416 if (obj0) {
5417 ecode1 = SWIG_AsVal_double(obj0, &val1);
5418 if (!SWIG_IsOK(ecode1)) {
5419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5420 }
5421 arg1 = static_cast< double >(val1);
5422 }
5423 if (obj1) {
5424 ecode2 = SWIG_AsVal_double(obj1, &val2);
5425 if (!SWIG_IsOK(ecode2)) {
5426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5427 }
5428 arg2 = static_cast< double >(val2);
5429 }
5430 {
5431 PyThreadState* __tstate = wxPyBeginAllowThreads();
5432 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5433 wxPyEndAllowThreads(__tstate);
5434 if (PyErr_Occurred()) SWIG_fail;
5435 }
5436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5444 PyObject *resultobj = 0;
5445 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5446 void *argp1 = 0 ;
5447 int res1 = 0 ;
5448 PyObject *swig_obj[1] ;
5449
5450 if (!args) SWIG_fail;
5451 swig_obj[0] = args;
5452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5453 if (!SWIG_IsOK(res1)) {
5454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5455 }
5456 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5457 {
5458 PyThreadState* __tstate = wxPyBeginAllowThreads();
5459 delete arg1;
5460
5461 wxPyEndAllowThreads(__tstate);
5462 if (PyErr_Occurred()) SWIG_fail;
5463 }
5464 resultobj = SWIG_Py_Void();
5465 return resultobj;
5466 fail:
5467 return NULL;
5468 }
5469
5470
5471 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5472 PyObject *resultobj = 0;
5473 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5474 PyObject *arg2 = (PyObject *) 0 ;
5475 bool result;
5476 void *argp1 = 0 ;
5477 int res1 = 0 ;
5478 PyObject * obj0 = 0 ;
5479 PyObject * obj1 = 0 ;
5480 char * kwnames[] = {
5481 (char *) "self",(char *) "other", NULL
5482 };
5483
5484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5486 if (!SWIG_IsOK(res1)) {
5487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5488 }
5489 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5490 arg2 = obj1;
5491 {
5492 result = (bool)wxRealPoint___eq__(arg1,arg2);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 {
5496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5497 }
5498 return resultobj;
5499 fail:
5500 return NULL;
5501 }
5502
5503
5504 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj = 0;
5506 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5507 PyObject *arg2 = (PyObject *) 0 ;
5508 bool result;
5509 void *argp1 = 0 ;
5510 int res1 = 0 ;
5511 PyObject * obj0 = 0 ;
5512 PyObject * obj1 = 0 ;
5513 char * kwnames[] = {
5514 (char *) "self",(char *) "other", NULL
5515 };
5516
5517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5519 if (!SWIG_IsOK(res1)) {
5520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5521 }
5522 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5523 arg2 = obj1;
5524 {
5525 result = (bool)wxRealPoint___ne__(arg1,arg2);
5526 if (PyErr_Occurred()) SWIG_fail;
5527 }
5528 {
5529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5530 }
5531 return resultobj;
5532 fail:
5533 return NULL;
5534 }
5535
5536
5537 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5538 PyObject *resultobj = 0;
5539 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5540 wxRealPoint *arg2 = 0 ;
5541 wxRealPoint result;
5542 void *argp1 = 0 ;
5543 int res1 = 0 ;
5544 wxRealPoint temp2 ;
5545 PyObject * obj0 = 0 ;
5546 PyObject * obj1 = 0 ;
5547 char * kwnames[] = {
5548 (char *) "self",(char *) "pt", NULL
5549 };
5550
5551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5553 if (!SWIG_IsOK(res1)) {
5554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5555 }
5556 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5557 {
5558 arg2 = &temp2;
5559 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5560 }
5561 {
5562 PyThreadState* __tstate = wxPyBeginAllowThreads();
5563 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5564 wxPyEndAllowThreads(__tstate);
5565 if (PyErr_Occurred()) SWIG_fail;
5566 }
5567 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj = 0;
5576 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5577 wxRealPoint *arg2 = 0 ;
5578 wxRealPoint result;
5579 void *argp1 = 0 ;
5580 int res1 = 0 ;
5581 wxRealPoint temp2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char * kwnames[] = {
5585 (char *) "self",(char *) "pt", NULL
5586 };
5587
5588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5590 if (!SWIG_IsOK(res1)) {
5591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5592 }
5593 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5594 {
5595 arg2 = &temp2;
5596 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5597 }
5598 {
5599 PyThreadState* __tstate = wxPyBeginAllowThreads();
5600 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj = 0;
5613 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5614 double arg2 ;
5615 double arg3 ;
5616 void *argp1 = 0 ;
5617 int res1 = 0 ;
5618 double val2 ;
5619 int ecode2 = 0 ;
5620 double val3 ;
5621 int ecode3 = 0 ;
5622 PyObject * obj0 = 0 ;
5623 PyObject * obj1 = 0 ;
5624 PyObject * obj2 = 0 ;
5625 char * kwnames[] = {
5626 (char *) "self",(char *) "x",(char *) "y", NULL
5627 };
5628
5629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5631 if (!SWIG_IsOK(res1)) {
5632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5633 }
5634 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5635 ecode2 = SWIG_AsVal_double(obj1, &val2);
5636 if (!SWIG_IsOK(ecode2)) {
5637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5638 }
5639 arg2 = static_cast< double >(val2);
5640 ecode3 = SWIG_AsVal_double(obj2, &val3);
5641 if (!SWIG_IsOK(ecode3)) {
5642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5643 }
5644 arg3 = static_cast< double >(val3);
5645 {
5646 PyThreadState* __tstate = wxPyBeginAllowThreads();
5647 wxRealPoint_Set(arg1,arg2,arg3);
5648 wxPyEndAllowThreads(__tstate);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 resultobj = SWIG_Py_Void();
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5659 PyObject *resultobj = 0;
5660 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5661 PyObject *result = 0 ;
5662 void *argp1 = 0 ;
5663 int res1 = 0 ;
5664 PyObject *swig_obj[1] ;
5665
5666 if (!args) SWIG_fail;
5667 swig_obj[0] = args;
5668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5669 if (!SWIG_IsOK(res1)) {
5670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5671 }
5672 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5673 {
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 result = (PyObject *)wxRealPoint_Get(arg1);
5676 wxPyEndAllowThreads(__tstate);
5677 if (PyErr_Occurred()) SWIG_fail;
5678 }
5679 resultobj = result;
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5687 PyObject *obj;
5688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5689 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5690 return SWIG_Py_Void();
5691 }
5692
5693 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5694 return SWIG_Python_InitShadowInstance(args);
5695 }
5696
5697 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5698 PyObject *resultobj = 0;
5699 wxPoint *arg1 = (wxPoint *) 0 ;
5700 int arg2 ;
5701 void *argp1 = 0 ;
5702 int res1 = 0 ;
5703 int val2 ;
5704 int ecode2 = 0 ;
5705 PyObject *swig_obj[2] ;
5706
5707 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5709 if (!SWIG_IsOK(res1)) {
5710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5711 }
5712 arg1 = reinterpret_cast< wxPoint * >(argp1);
5713 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5714 if (!SWIG_IsOK(ecode2)) {
5715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5716 }
5717 arg2 = static_cast< int >(val2);
5718 if (arg1) (arg1)->x = arg2;
5719
5720 resultobj = SWIG_Py_Void();
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5728 PyObject *resultobj = 0;
5729 wxPoint *arg1 = (wxPoint *) 0 ;
5730 int result;
5731 void *argp1 = 0 ;
5732 int res1 = 0 ;
5733 PyObject *swig_obj[1] ;
5734
5735 if (!args) SWIG_fail;
5736 swig_obj[0] = args;
5737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5738 if (!SWIG_IsOK(res1)) {
5739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5740 }
5741 arg1 = reinterpret_cast< wxPoint * >(argp1);
5742 result = (int) ((arg1)->x);
5743 resultobj = SWIG_From_int(static_cast< int >(result));
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5751 PyObject *resultobj = 0;
5752 wxPoint *arg1 = (wxPoint *) 0 ;
5753 int arg2 ;
5754 void *argp1 = 0 ;
5755 int res1 = 0 ;
5756 int val2 ;
5757 int ecode2 = 0 ;
5758 PyObject *swig_obj[2] ;
5759
5760 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5764 }
5765 arg1 = reinterpret_cast< wxPoint * >(argp1);
5766 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5767 if (!SWIG_IsOK(ecode2)) {
5768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5769 }
5770 arg2 = static_cast< int >(val2);
5771 if (arg1) (arg1)->y = arg2;
5772
5773 resultobj = SWIG_Py_Void();
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5781 PyObject *resultobj = 0;
5782 wxPoint *arg1 = (wxPoint *) 0 ;
5783 int result;
5784 void *argp1 = 0 ;
5785 int res1 = 0 ;
5786 PyObject *swig_obj[1] ;
5787
5788 if (!args) SWIG_fail;
5789 swig_obj[0] = args;
5790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5791 if (!SWIG_IsOK(res1)) {
5792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5793 }
5794 arg1 = reinterpret_cast< wxPoint * >(argp1);
5795 result = (int) ((arg1)->y);
5796 resultobj = SWIG_From_int(static_cast< int >(result));
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj = 0;
5805 int arg1 = (int) 0 ;
5806 int arg2 = (int) 0 ;
5807 wxPoint *result = 0 ;
5808 int val1 ;
5809 int ecode1 = 0 ;
5810 int val2 ;
5811 int ecode2 = 0 ;
5812 PyObject * obj0 = 0 ;
5813 PyObject * obj1 = 0 ;
5814 char * kwnames[] = {
5815 (char *) "x",(char *) "y", NULL
5816 };
5817
5818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5819 if (obj0) {
5820 ecode1 = SWIG_AsVal_int(obj0, &val1);
5821 if (!SWIG_IsOK(ecode1)) {
5822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5823 }
5824 arg1 = static_cast< int >(val1);
5825 }
5826 if (obj1) {
5827 ecode2 = SWIG_AsVal_int(obj1, &val2);
5828 if (!SWIG_IsOK(ecode2)) {
5829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5830 }
5831 arg2 = static_cast< int >(val2);
5832 }
5833 {
5834 PyThreadState* __tstate = wxPyBeginAllowThreads();
5835 result = (wxPoint *)new wxPoint(arg1,arg2);
5836 wxPyEndAllowThreads(__tstate);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5847 PyObject *resultobj = 0;
5848 wxPoint *arg1 = (wxPoint *) 0 ;
5849 void *argp1 = 0 ;
5850 int res1 = 0 ;
5851 PyObject *swig_obj[1] ;
5852
5853 if (!args) SWIG_fail;
5854 swig_obj[0] = args;
5855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5856 if (!SWIG_IsOK(res1)) {
5857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5858 }
5859 arg1 = reinterpret_cast< wxPoint * >(argp1);
5860 {
5861 PyThreadState* __tstate = wxPyBeginAllowThreads();
5862 delete arg1;
5863
5864 wxPyEndAllowThreads(__tstate);
5865 if (PyErr_Occurred()) SWIG_fail;
5866 }
5867 resultobj = SWIG_Py_Void();
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj = 0;
5876 wxPoint *arg1 = (wxPoint *) 0 ;
5877 PyObject *arg2 = (PyObject *) 0 ;
5878 bool result;
5879 void *argp1 = 0 ;
5880 int res1 = 0 ;
5881 PyObject * obj0 = 0 ;
5882 PyObject * obj1 = 0 ;
5883 char * kwnames[] = {
5884 (char *) "self",(char *) "other", NULL
5885 };
5886
5887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5889 if (!SWIG_IsOK(res1)) {
5890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5891 }
5892 arg1 = reinterpret_cast< wxPoint * >(argp1);
5893 arg2 = obj1;
5894 {
5895 result = (bool)wxPoint___eq__(arg1,arg2);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 {
5899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5900 }
5901 return resultobj;
5902 fail:
5903 return NULL;
5904 }
5905
5906
5907 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5908 PyObject *resultobj = 0;
5909 wxPoint *arg1 = (wxPoint *) 0 ;
5910 PyObject *arg2 = (PyObject *) 0 ;
5911 bool result;
5912 void *argp1 = 0 ;
5913 int res1 = 0 ;
5914 PyObject * obj0 = 0 ;
5915 PyObject * obj1 = 0 ;
5916 char * kwnames[] = {
5917 (char *) "self",(char *) "other", NULL
5918 };
5919
5920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5922 if (!SWIG_IsOK(res1)) {
5923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5924 }
5925 arg1 = reinterpret_cast< wxPoint * >(argp1);
5926 arg2 = obj1;
5927 {
5928 result = (bool)wxPoint___ne__(arg1,arg2);
5929 if (PyErr_Occurred()) SWIG_fail;
5930 }
5931 {
5932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5933 }
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = 0;
5942 wxPoint *arg1 = (wxPoint *) 0 ;
5943 wxPoint *arg2 = 0 ;
5944 wxPoint result;
5945 void *argp1 = 0 ;
5946 int res1 = 0 ;
5947 wxPoint temp2 ;
5948 PyObject * obj0 = 0 ;
5949 PyObject * obj1 = 0 ;
5950 char * kwnames[] = {
5951 (char *) "self",(char *) "pt", NULL
5952 };
5953
5954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5956 if (!SWIG_IsOK(res1)) {
5957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5958 }
5959 arg1 = reinterpret_cast< wxPoint * >(argp1);
5960 {
5961 arg2 = &temp2;
5962 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5963 }
5964 {
5965 PyThreadState* __tstate = wxPyBeginAllowThreads();
5966 result = (arg1)->operator +((wxPoint const &)*arg2);
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5971 return resultobj;
5972 fail:
5973 return NULL;
5974 }
5975
5976
5977 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5978 PyObject *resultobj = 0;
5979 wxPoint *arg1 = (wxPoint *) 0 ;
5980 wxPoint *arg2 = 0 ;
5981 wxPoint result;
5982 void *argp1 = 0 ;
5983 int res1 = 0 ;
5984 wxPoint temp2 ;
5985 PyObject * obj0 = 0 ;
5986 PyObject * obj1 = 0 ;
5987 char * kwnames[] = {
5988 (char *) "self",(char *) "pt", NULL
5989 };
5990
5991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5993 if (!SWIG_IsOK(res1)) {
5994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5995 }
5996 arg1 = reinterpret_cast< wxPoint * >(argp1);
5997 {
5998 arg2 = &temp2;
5999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6000 }
6001 {
6002 PyThreadState* __tstate = wxPyBeginAllowThreads();
6003 result = (arg1)->operator -((wxPoint const &)*arg2);
6004 wxPyEndAllowThreads(__tstate);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj = 0;
6016 wxPoint *arg1 = (wxPoint *) 0 ;
6017 wxPoint *arg2 = 0 ;
6018 wxPoint *result = 0 ;
6019 void *argp1 = 0 ;
6020 int res1 = 0 ;
6021 wxPoint temp2 ;
6022 PyObject * obj0 = 0 ;
6023 PyObject * obj1 = 0 ;
6024 char * kwnames[] = {
6025 (char *) "self",(char *) "pt", NULL
6026 };
6027
6028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6030 if (!SWIG_IsOK(res1)) {
6031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6032 }
6033 arg1 = reinterpret_cast< wxPoint * >(argp1);
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 {
6041 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6042 result = (wxPoint *) &_result_ref;
6043 }
6044 wxPyEndAllowThreads(__tstate);
6045 if (PyErr_Occurred()) SWIG_fail;
6046 }
6047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6048 return resultobj;
6049 fail:
6050 return NULL;
6051 }
6052
6053
6054 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj = 0;
6056 wxPoint *arg1 = (wxPoint *) 0 ;
6057 wxPoint *arg2 = 0 ;
6058 wxPoint *result = 0 ;
6059 void *argp1 = 0 ;
6060 int res1 = 0 ;
6061 wxPoint temp2 ;
6062 PyObject * obj0 = 0 ;
6063 PyObject * obj1 = 0 ;
6064 char * kwnames[] = {
6065 (char *) "self",(char *) "pt", NULL
6066 };
6067
6068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6070 if (!SWIG_IsOK(res1)) {
6071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6072 }
6073 arg1 = reinterpret_cast< wxPoint * >(argp1);
6074 {
6075 arg2 = &temp2;
6076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 {
6081 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6082 result = (wxPoint *) &_result_ref;
6083 }
6084 wxPyEndAllowThreads(__tstate);
6085 if (PyErr_Occurred()) SWIG_fail;
6086 }
6087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj = 0;
6096 wxPoint *arg1 = (wxPoint *) 0 ;
6097 long arg2 ;
6098 long arg3 ;
6099 void *argp1 = 0 ;
6100 int res1 = 0 ;
6101 long val2 ;
6102 int ecode2 = 0 ;
6103 long val3 ;
6104 int ecode3 = 0 ;
6105 PyObject * obj0 = 0 ;
6106 PyObject * obj1 = 0 ;
6107 PyObject * obj2 = 0 ;
6108 char * kwnames[] = {
6109 (char *) "self",(char *) "x",(char *) "y", NULL
6110 };
6111
6112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6114 if (!SWIG_IsOK(res1)) {
6115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6116 }
6117 arg1 = reinterpret_cast< wxPoint * >(argp1);
6118 ecode2 = SWIG_AsVal_long(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6121 }
6122 arg2 = static_cast< long >(val2);
6123 ecode3 = SWIG_AsVal_long(obj2, &val3);
6124 if (!SWIG_IsOK(ecode3)) {
6125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6126 }
6127 arg3 = static_cast< long >(val3);
6128 {
6129 PyThreadState* __tstate = wxPyBeginAllowThreads();
6130 wxPoint_Set(arg1,arg2,arg3);
6131 wxPyEndAllowThreads(__tstate);
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 resultobj = SWIG_Py_Void();
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6142 PyObject *resultobj = 0;
6143 wxPoint *arg1 = (wxPoint *) 0 ;
6144 PyObject *result = 0 ;
6145 void *argp1 = 0 ;
6146 int res1 = 0 ;
6147 PyObject *swig_obj[1] ;
6148
6149 if (!args) SWIG_fail;
6150 swig_obj[0] = args;
6151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6152 if (!SWIG_IsOK(res1)) {
6153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6154 }
6155 arg1 = reinterpret_cast< wxPoint * >(argp1);
6156 {
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (PyObject *)wxPoint_Get(arg1);
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = result;
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *obj;
6171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6172 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6173 return SWIG_Py_Void();
6174 }
6175
6176 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6177 return SWIG_Python_InitShadowInstance(args);
6178 }
6179
6180 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj = 0;
6182 int arg1 = (int) 0 ;
6183 int arg2 = (int) 0 ;
6184 int arg3 = (int) 0 ;
6185 int arg4 = (int) 0 ;
6186 wxRect *result = 0 ;
6187 int val1 ;
6188 int ecode1 = 0 ;
6189 int val2 ;
6190 int ecode2 = 0 ;
6191 int val3 ;
6192 int ecode3 = 0 ;
6193 int val4 ;
6194 int ecode4 = 0 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 PyObject * obj2 = 0 ;
6198 PyObject * obj3 = 0 ;
6199 char * kwnames[] = {
6200 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6201 };
6202
6203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6204 if (obj0) {
6205 ecode1 = SWIG_AsVal_int(obj0, &val1);
6206 if (!SWIG_IsOK(ecode1)) {
6207 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6208 }
6209 arg1 = static_cast< int >(val1);
6210 }
6211 if (obj1) {
6212 ecode2 = SWIG_AsVal_int(obj1, &val2);
6213 if (!SWIG_IsOK(ecode2)) {
6214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6215 }
6216 arg2 = static_cast< int >(val2);
6217 }
6218 if (obj2) {
6219 ecode3 = SWIG_AsVal_int(obj2, &val3);
6220 if (!SWIG_IsOK(ecode3)) {
6221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6222 }
6223 arg3 = static_cast< int >(val3);
6224 }
6225 if (obj3) {
6226 ecode4 = SWIG_AsVal_int(obj3, &val4);
6227 if (!SWIG_IsOK(ecode4)) {
6228 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6229 }
6230 arg4 = static_cast< int >(val4);
6231 }
6232 {
6233 PyThreadState* __tstate = wxPyBeginAllowThreads();
6234 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6235 wxPyEndAllowThreads(__tstate);
6236 if (PyErr_Occurred()) SWIG_fail;
6237 }
6238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6239 return resultobj;
6240 fail:
6241 return NULL;
6242 }
6243
6244
6245 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6246 PyObject *resultobj = 0;
6247 wxPoint *arg1 = 0 ;
6248 wxPoint *arg2 = 0 ;
6249 wxRect *result = 0 ;
6250 wxPoint temp1 ;
6251 wxPoint temp2 ;
6252 PyObject * obj0 = 0 ;
6253 PyObject * obj1 = 0 ;
6254 char * kwnames[] = {
6255 (char *) "topLeft",(char *) "bottomRight", NULL
6256 };
6257
6258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6259 {
6260 arg1 = &temp1;
6261 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6262 }
6263 {
6264 arg2 = &temp2;
6265 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6266 }
6267 {
6268 PyThreadState* __tstate = wxPyBeginAllowThreads();
6269 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6270 wxPyEndAllowThreads(__tstate);
6271 if (PyErr_Occurred()) SWIG_fail;
6272 }
6273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
6280 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj = 0;
6282 wxPoint *arg1 = 0 ;
6283 wxSize *arg2 = 0 ;
6284 wxRect *result = 0 ;
6285 wxPoint temp1 ;
6286 wxSize temp2 ;
6287 PyObject * obj0 = 0 ;
6288 PyObject * obj1 = 0 ;
6289 char * kwnames[] = {
6290 (char *) "pos",(char *) "size", NULL
6291 };
6292
6293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6294 {
6295 arg1 = &temp1;
6296 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6297 }
6298 {
6299 arg2 = &temp2;
6300 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6301 }
6302 {
6303 PyThreadState* __tstate = wxPyBeginAllowThreads();
6304 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6305 wxPyEndAllowThreads(__tstate);
6306 if (PyErr_Occurred()) SWIG_fail;
6307 }
6308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6309 return resultobj;
6310 fail:
6311 return NULL;
6312 }
6313
6314
6315 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6316 PyObject *resultobj = 0;
6317 wxSize *arg1 = 0 ;
6318 wxRect *result = 0 ;
6319 wxSize temp1 ;
6320 PyObject * obj0 = 0 ;
6321 char * kwnames[] = {
6322 (char *) "size", NULL
6323 };
6324
6325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6326 {
6327 arg1 = &temp1;
6328 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6329 }
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 void *argp1 = 0 ;
6347 int res1 = 0 ;
6348 PyObject *swig_obj[1] ;
6349
6350 if (!args) SWIG_fail;
6351 swig_obj[0] = args;
6352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6353 if (!SWIG_IsOK(res1)) {
6354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6355 }
6356 arg1 = reinterpret_cast< wxRect * >(argp1);
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 delete arg1;
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_Py_Void();
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 int result;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 PyObject *swig_obj[1] ;
6378
6379 if (!args) SWIG_fail;
6380 swig_obj[0] = args;
6381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6382 if (!SWIG_IsOK(res1)) {
6383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6384 }
6385 arg1 = reinterpret_cast< wxRect * >(argp1);
6386 {
6387 PyThreadState* __tstate = wxPyBeginAllowThreads();
6388 result = (int)((wxRect const *)arg1)->GetX();
6389 wxPyEndAllowThreads(__tstate);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_From_int(static_cast< int >(result));
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 int arg2 ;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 int val2 ;
6406 int ecode2 = 0 ;
6407 PyObject * obj0 = 0 ;
6408 PyObject * obj1 = 0 ;
6409 char * kwnames[] = {
6410 (char *) "self",(char *) "x", NULL
6411 };
6412
6413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6415 if (!SWIG_IsOK(res1)) {
6416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6417 }
6418 arg1 = reinterpret_cast< wxRect * >(argp1);
6419 ecode2 = SWIG_AsVal_int(obj1, &val2);
6420 if (!SWIG_IsOK(ecode2)) {
6421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6422 }
6423 arg2 = static_cast< int >(val2);
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 (arg1)->SetX(arg2);
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_Py_Void();
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 int result;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 PyObject *swig_obj[1] ;
6444
6445 if (!args) SWIG_fail;
6446 swig_obj[0] = args;
6447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6448 if (!SWIG_IsOK(res1)) {
6449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6450 }
6451 arg1 = reinterpret_cast< wxRect * >(argp1);
6452 {
6453 PyThreadState* __tstate = wxPyBeginAllowThreads();
6454 result = (int)(arg1)->GetY();
6455 wxPyEndAllowThreads(__tstate);
6456 if (PyErr_Occurred()) SWIG_fail;
6457 }
6458 resultobj = SWIG_From_int(static_cast< int >(result));
6459 return resultobj;
6460 fail:
6461 return NULL;
6462 }
6463
6464
6465 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6466 PyObject *resultobj = 0;
6467 wxRect *arg1 = (wxRect *) 0 ;
6468 int arg2 ;
6469 void *argp1 = 0 ;
6470 int res1 = 0 ;
6471 int val2 ;
6472 int ecode2 = 0 ;
6473 PyObject * obj0 = 0 ;
6474 PyObject * obj1 = 0 ;
6475 char * kwnames[] = {
6476 (char *) "self",(char *) "y", NULL
6477 };
6478
6479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6481 if (!SWIG_IsOK(res1)) {
6482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6483 }
6484 arg1 = reinterpret_cast< wxRect * >(argp1);
6485 ecode2 = SWIG_AsVal_int(obj1, &val2);
6486 if (!SWIG_IsOK(ecode2)) {
6487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6488 }
6489 arg2 = static_cast< int >(val2);
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 (arg1)->SetY(arg2);
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_Py_Void();
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6504 PyObject *resultobj = 0;
6505 wxRect *arg1 = (wxRect *) 0 ;
6506 int result;
6507 void *argp1 = 0 ;
6508 int res1 = 0 ;
6509 PyObject *swig_obj[1] ;
6510
6511 if (!args) SWIG_fail;
6512 swig_obj[0] = args;
6513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6514 if (!SWIG_IsOK(res1)) {
6515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6516 }
6517 arg1 = reinterpret_cast< wxRect * >(argp1);
6518 {
6519 PyThreadState* __tstate = wxPyBeginAllowThreads();
6520 result = (int)((wxRect const *)arg1)->GetWidth();
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 resultobj = SWIG_From_int(static_cast< int >(result));
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6532 PyObject *resultobj = 0;
6533 wxRect *arg1 = (wxRect *) 0 ;
6534 int arg2 ;
6535 void *argp1 = 0 ;
6536 int res1 = 0 ;
6537 int val2 ;
6538 int ecode2 = 0 ;
6539 PyObject * obj0 = 0 ;
6540 PyObject * obj1 = 0 ;
6541 char * kwnames[] = {
6542 (char *) "self",(char *) "w", NULL
6543 };
6544
6545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6547 if (!SWIG_IsOK(res1)) {
6548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6549 }
6550 arg1 = reinterpret_cast< wxRect * >(argp1);
6551 ecode2 = SWIG_AsVal_int(obj1, &val2);
6552 if (!SWIG_IsOK(ecode2)) {
6553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6554 }
6555 arg2 = static_cast< int >(val2);
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 (arg1)->SetWidth(arg2);
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_Py_Void();
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6570 PyObject *resultobj = 0;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 int result;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 PyObject *swig_obj[1] ;
6576
6577 if (!args) SWIG_fail;
6578 swig_obj[0] = args;
6579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6580 if (!SWIG_IsOK(res1)) {
6581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6582 }
6583 arg1 = reinterpret_cast< wxRect * >(argp1);
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 result = (int)((wxRect const *)arg1)->GetHeight();
6587 wxPyEndAllowThreads(__tstate);
6588 if (PyErr_Occurred()) SWIG_fail;
6589 }
6590 resultobj = SWIG_From_int(static_cast< int >(result));
6591 return resultobj;
6592 fail:
6593 return NULL;
6594 }
6595
6596
6597 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6598 PyObject *resultobj = 0;
6599 wxRect *arg1 = (wxRect *) 0 ;
6600 int arg2 ;
6601 void *argp1 = 0 ;
6602 int res1 = 0 ;
6603 int val2 ;
6604 int ecode2 = 0 ;
6605 PyObject * obj0 = 0 ;
6606 PyObject * obj1 = 0 ;
6607 char * kwnames[] = {
6608 (char *) "self",(char *) "h", NULL
6609 };
6610
6611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6613 if (!SWIG_IsOK(res1)) {
6614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6615 }
6616 arg1 = reinterpret_cast< wxRect * >(argp1);
6617 ecode2 = SWIG_AsVal_int(obj1, &val2);
6618 if (!SWIG_IsOK(ecode2)) {
6619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6620 }
6621 arg2 = static_cast< int >(val2);
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 (arg1)->SetHeight(arg2);
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_Py_Void();
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 wxPoint result;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 PyObject *swig_obj[1] ;
6642
6643 if (!args) SWIG_fail;
6644 swig_obj[0] = args;
6645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6646 if (!SWIG_IsOK(res1)) {
6647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6648 }
6649 arg1 = reinterpret_cast< wxRect * >(argp1);
6650 {
6651 PyThreadState* __tstate = wxPyBeginAllowThreads();
6652 result = ((wxRect const *)arg1)->GetPosition();
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6657 return resultobj;
6658 fail:
6659 return NULL;
6660 }
6661
6662
6663 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6664 PyObject *resultobj = 0;
6665 wxRect *arg1 = (wxRect *) 0 ;
6666 wxPoint *arg2 = 0 ;
6667 void *argp1 = 0 ;
6668 int res1 = 0 ;
6669 wxPoint temp2 ;
6670 PyObject * obj0 = 0 ;
6671 PyObject * obj1 = 0 ;
6672 char * kwnames[] = {
6673 (char *) "self",(char *) "p", NULL
6674 };
6675
6676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6678 if (!SWIG_IsOK(res1)) {
6679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6680 }
6681 arg1 = reinterpret_cast< wxRect * >(argp1);
6682 {
6683 arg2 = &temp2;
6684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6685 }
6686 {
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 (arg1)->SetPosition((wxPoint const &)*arg2);
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 resultobj = SWIG_Py_Void();
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 wxRect *arg1 = (wxRect *) 0 ;
6702 wxSize result;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 if (!args) SWIG_fail;
6708 swig_obj[0] = args;
6709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6710 if (!SWIG_IsOK(res1)) {
6711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6712 }
6713 arg1 = reinterpret_cast< wxRect * >(argp1);
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = ((wxRect const *)arg1)->GetSize();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6728 PyObject *resultobj = 0;
6729 wxRect *arg1 = (wxRect *) 0 ;
6730 wxSize *arg2 = 0 ;
6731 void *argp1 = 0 ;
6732 int res1 = 0 ;
6733 wxSize temp2 ;
6734 PyObject * obj0 = 0 ;
6735 PyObject * obj1 = 0 ;
6736 char * kwnames[] = {
6737 (char *) "self",(char *) "s", NULL
6738 };
6739
6740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6744 }
6745 arg1 = reinterpret_cast< wxRect * >(argp1);
6746 {
6747 arg2 = &temp2;
6748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetSize((wxSize const &)*arg2);
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_Py_Void();
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxRect *arg1 = (wxRect *) 0 ;
6766 bool result;
6767 void *argp1 = 0 ;
6768 int res1 = 0 ;
6769 PyObject *swig_obj[1] ;
6770
6771 if (!args) SWIG_fail;
6772 swig_obj[0] = args;
6773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = (bool)((wxRect const *)arg1)->IsEmpty();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 {
6785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6786 }
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxRect *arg1 = (wxRect *) 0 ;
6796 wxPoint result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxRect * >(argp1);
6808 {
6809 PyThreadState* __tstate = wxPyBeginAllowThreads();
6810 result = ((wxRect const *)arg1)->GetTopLeft();
6811 wxPyEndAllowThreads(__tstate);
6812 if (PyErr_Occurred()) SWIG_fail;
6813 }
6814 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6822 PyObject *resultobj = 0;
6823 wxRect *arg1 = (wxRect *) 0 ;
6824 wxPoint *arg2 = 0 ;
6825 void *argp1 = 0 ;
6826 int res1 = 0 ;
6827 wxPoint temp2 ;
6828 PyObject * obj0 = 0 ;
6829 PyObject * obj1 = 0 ;
6830 char * kwnames[] = {
6831 (char *) "self",(char *) "p", NULL
6832 };
6833
6834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6836 if (!SWIG_IsOK(res1)) {
6837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6838 }
6839 arg1 = reinterpret_cast< wxRect * >(argp1);
6840 {
6841 arg2 = &temp2;
6842 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6843 }
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 resultobj = SWIG_Py_Void();
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6858 PyObject *resultobj = 0;
6859 wxRect *arg1 = (wxRect *) 0 ;
6860 wxPoint result;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 PyObject *swig_obj[1] ;
6864
6865 if (!args) SWIG_fail;
6866 swig_obj[0] = args;
6867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6868 if (!SWIG_IsOK(res1)) {
6869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6870 }
6871 arg1 = reinterpret_cast< wxRect * >(argp1);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 result = ((wxRect const *)arg1)->GetBottomRight();
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6886 PyObject *resultobj = 0;
6887 wxRect *arg1 = (wxRect *) 0 ;
6888 wxPoint *arg2 = 0 ;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 wxPoint temp2 ;
6892 PyObject * obj0 = 0 ;
6893 PyObject * obj1 = 0 ;
6894 char * kwnames[] = {
6895 (char *) "self",(char *) "p", NULL
6896 };
6897
6898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6900 if (!SWIG_IsOK(res1)) {
6901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6902 }
6903 arg1 = reinterpret_cast< wxRect * >(argp1);
6904 {
6905 arg2 = &temp2;
6906 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6907 }
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6911 wxPyEndAllowThreads(__tstate);
6912 if (PyErr_Occurred()) SWIG_fail;
6913 }
6914 resultobj = SWIG_Py_Void();
6915 return resultobj;
6916 fail:
6917 return NULL;
6918 }
6919
6920
6921 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6922 PyObject *resultobj = 0;
6923 wxRect *arg1 = (wxRect *) 0 ;
6924 wxPoint result;
6925 void *argp1 = 0 ;
6926 int res1 = 0 ;
6927 PyObject *swig_obj[1] ;
6928
6929 if (!args) SWIG_fail;
6930 swig_obj[0] = args;
6931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6932 if (!SWIG_IsOK(res1)) {
6933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6934 }
6935 arg1 = reinterpret_cast< wxRect * >(argp1);
6936 {
6937 PyThreadState* __tstate = wxPyBeginAllowThreads();
6938 result = ((wxRect const *)arg1)->GetTopRight();
6939 wxPyEndAllowThreads(__tstate);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6943 return resultobj;
6944 fail:
6945 return NULL;
6946 }
6947
6948
6949 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6950 PyObject *resultobj = 0;
6951 wxRect *arg1 = (wxRect *) 0 ;
6952 wxPoint *arg2 = 0 ;
6953 void *argp1 = 0 ;
6954 int res1 = 0 ;
6955 wxPoint temp2 ;
6956 PyObject * obj0 = 0 ;
6957 PyObject * obj1 = 0 ;
6958 char * kwnames[] = {
6959 (char *) "self",(char *) "p", NULL
6960 };
6961
6962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6964 if (!SWIG_IsOK(res1)) {
6965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6966 }
6967 arg1 = reinterpret_cast< wxRect * >(argp1);
6968 {
6969 arg2 = &temp2;
6970 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6971 }
6972 {
6973 PyThreadState* __tstate = wxPyBeginAllowThreads();
6974 (arg1)->SetTopRight((wxPoint const &)*arg2);
6975 wxPyEndAllowThreads(__tstate);
6976 if (PyErr_Occurred()) SWIG_fail;
6977 }
6978 resultobj = SWIG_Py_Void();
6979 return resultobj;
6980 fail:
6981 return NULL;
6982 }
6983
6984
6985 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6986 PyObject *resultobj = 0;
6987 wxRect *arg1 = (wxRect *) 0 ;
6988 wxPoint result;
6989 void *argp1 = 0 ;
6990 int res1 = 0 ;
6991 PyObject *swig_obj[1] ;
6992
6993 if (!args) SWIG_fail;
6994 swig_obj[0] = args;
6995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6996 if (!SWIG_IsOK(res1)) {
6997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6998 }
6999 arg1 = reinterpret_cast< wxRect * >(argp1);
7000 {
7001 PyThreadState* __tstate = wxPyBeginAllowThreads();
7002 result = ((wxRect const *)arg1)->GetBottomLeft();
7003 wxPyEndAllowThreads(__tstate);
7004 if (PyErr_Occurred()) SWIG_fail;
7005 }
7006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7007 return resultobj;
7008 fail:
7009 return NULL;
7010 }
7011
7012
7013 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7014 PyObject *resultobj = 0;
7015 wxRect *arg1 = (wxRect *) 0 ;
7016 wxPoint *arg2 = 0 ;
7017 void *argp1 = 0 ;
7018 int res1 = 0 ;
7019 wxPoint temp2 ;
7020 PyObject * obj0 = 0 ;
7021 PyObject * obj1 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "self",(char *) "p", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7028 if (!SWIG_IsOK(res1)) {
7029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7030 }
7031 arg1 = reinterpret_cast< wxRect * >(argp1);
7032 {
7033 arg2 = &temp2;
7034 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7035 }
7036 {
7037 PyThreadState* __tstate = wxPyBeginAllowThreads();
7038 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 resultobj = SWIG_Py_Void();
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7050 PyObject *resultobj = 0;
7051 wxRect *arg1 = (wxRect *) 0 ;
7052 int result;
7053 void *argp1 = 0 ;
7054 int res1 = 0 ;
7055 PyObject *swig_obj[1] ;
7056
7057 if (!args) SWIG_fail;
7058 swig_obj[0] = args;
7059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7060 if (!SWIG_IsOK(res1)) {
7061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7062 }
7063 arg1 = reinterpret_cast< wxRect * >(argp1);
7064 {
7065 PyThreadState* __tstate = wxPyBeginAllowThreads();
7066 result = (int)((wxRect const *)arg1)->GetLeft();
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_From_int(static_cast< int >(result));
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7078 PyObject *resultobj = 0;
7079 wxRect *arg1 = (wxRect *) 0 ;
7080 int result;
7081 void *argp1 = 0 ;
7082 int res1 = 0 ;
7083 PyObject *swig_obj[1] ;
7084
7085 if (!args) SWIG_fail;
7086 swig_obj[0] = args;
7087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7088 if (!SWIG_IsOK(res1)) {
7089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7090 }
7091 arg1 = reinterpret_cast< wxRect * >(argp1);
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 result = (int)((wxRect const *)arg1)->GetTop();
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_From_int(static_cast< int >(result));
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 PyObject *resultobj = 0;
7107 wxRect *arg1 = (wxRect *) 0 ;
7108 int result;
7109 void *argp1 = 0 ;
7110 int res1 = 0 ;
7111 PyObject *swig_obj[1] ;
7112
7113 if (!args) SWIG_fail;
7114 swig_obj[0] = args;
7115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7116 if (!SWIG_IsOK(res1)) {
7117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7118 }
7119 arg1 = reinterpret_cast< wxRect * >(argp1);
7120 {
7121 PyThreadState* __tstate = wxPyBeginAllowThreads();
7122 result = (int)((wxRect const *)arg1)->GetBottom();
7123 wxPyEndAllowThreads(__tstate);
7124 if (PyErr_Occurred()) SWIG_fail;
7125 }
7126 resultobj = SWIG_From_int(static_cast< int >(result));
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7134 PyObject *resultobj = 0;
7135 wxRect *arg1 = (wxRect *) 0 ;
7136 int result;
7137 void *argp1 = 0 ;
7138 int res1 = 0 ;
7139 PyObject *swig_obj[1] ;
7140
7141 if (!args) SWIG_fail;
7142 swig_obj[0] = args;
7143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 {
7149 PyThreadState* __tstate = wxPyBeginAllowThreads();
7150 result = (int)((wxRect const *)arg1)->GetRight();
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 resultobj = SWIG_From_int(static_cast< int >(result));
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj = 0;
7163 wxRect *arg1 = (wxRect *) 0 ;
7164 int arg2 ;
7165 void *argp1 = 0 ;
7166 int res1 = 0 ;
7167 int val2 ;
7168 int ecode2 = 0 ;
7169 PyObject * obj0 = 0 ;
7170 PyObject * obj1 = 0 ;
7171 char * kwnames[] = {
7172 (char *) "self",(char *) "left", NULL
7173 };
7174
7175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7177 if (!SWIG_IsOK(res1)) {
7178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7179 }
7180 arg1 = reinterpret_cast< wxRect * >(argp1);
7181 ecode2 = SWIG_AsVal_int(obj1, &val2);
7182 if (!SWIG_IsOK(ecode2)) {
7183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7184 }
7185 arg2 = static_cast< int >(val2);
7186 {
7187 PyThreadState* __tstate = wxPyBeginAllowThreads();
7188 (arg1)->SetLeft(arg2);
7189 wxPyEndAllowThreads(__tstate);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_Py_Void();
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 int arg2 ;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 int val2 ;
7206 int ecode2 = 0 ;
7207 PyObject * obj0 = 0 ;
7208 PyObject * obj1 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "right", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 ecode2 = SWIG_AsVal_int(obj1, &val2);
7220 if (!SWIG_IsOK(ecode2)) {
7221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7222 }
7223 arg2 = static_cast< int >(val2);
7224 {
7225 PyThreadState* __tstate = wxPyBeginAllowThreads();
7226 (arg1)->SetRight(arg2);
7227 wxPyEndAllowThreads(__tstate);
7228 if (PyErr_Occurred()) SWIG_fail;
7229 }
7230 resultobj = SWIG_Py_Void();
7231 return resultobj;
7232 fail:
7233 return NULL;
7234 }
7235
7236
7237 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7238 PyObject *resultobj = 0;
7239 wxRect *arg1 = (wxRect *) 0 ;
7240 int arg2 ;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 int val2 ;
7244 int ecode2 = 0 ;
7245 PyObject * obj0 = 0 ;
7246 PyObject * obj1 = 0 ;
7247 char * kwnames[] = {
7248 (char *) "self",(char *) "top", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7253 if (!SWIG_IsOK(res1)) {
7254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7255 }
7256 arg1 = reinterpret_cast< wxRect * >(argp1);
7257 ecode2 = SWIG_AsVal_int(obj1, &val2);
7258 if (!SWIG_IsOK(ecode2)) {
7259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7260 }
7261 arg2 = static_cast< int >(val2);
7262 {
7263 PyThreadState* __tstate = wxPyBeginAllowThreads();
7264 (arg1)->SetTop(arg2);
7265 wxPyEndAllowThreads(__tstate);
7266 if (PyErr_Occurred()) SWIG_fail;
7267 }
7268 resultobj = SWIG_Py_Void();
7269 return resultobj;
7270 fail:
7271 return NULL;
7272 }
7273
7274
7275 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7276 PyObject *resultobj = 0;
7277 wxRect *arg1 = (wxRect *) 0 ;
7278 int arg2 ;
7279 void *argp1 = 0 ;
7280 int res1 = 0 ;
7281 int val2 ;
7282 int ecode2 = 0 ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 char * kwnames[] = {
7286 (char *) "self",(char *) "bottom", NULL
7287 };
7288
7289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7291 if (!SWIG_IsOK(res1)) {
7292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7293 }
7294 arg1 = reinterpret_cast< wxRect * >(argp1);
7295 ecode2 = SWIG_AsVal_int(obj1, &val2);
7296 if (!SWIG_IsOK(ecode2)) {
7297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7298 }
7299 arg2 = static_cast< int >(val2);
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 (arg1)->SetBottom(arg2);
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 resultobj = SWIG_Py_Void();
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj = 0;
7315 wxRect *arg1 = (wxRect *) 0 ;
7316 int arg2 ;
7317 int arg3 ;
7318 wxRect *result = 0 ;
7319 void *argp1 = 0 ;
7320 int res1 = 0 ;
7321 int val2 ;
7322 int ecode2 = 0 ;
7323 int val3 ;
7324 int ecode3 = 0 ;
7325 PyObject * obj0 = 0 ;
7326 PyObject * obj1 = 0 ;
7327 PyObject * obj2 = 0 ;
7328 char * kwnames[] = {
7329 (char *) "self",(char *) "dx",(char *) "dy", NULL
7330 };
7331
7332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7334 if (!SWIG_IsOK(res1)) {
7335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7336 }
7337 arg1 = reinterpret_cast< wxRect * >(argp1);
7338 ecode2 = SWIG_AsVal_int(obj1, &val2);
7339 if (!SWIG_IsOK(ecode2)) {
7340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7341 }
7342 arg2 = static_cast< int >(val2);
7343 ecode3 = SWIG_AsVal_int(obj2, &val3);
7344 if (!SWIG_IsOK(ecode3)) {
7345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7346 }
7347 arg3 = static_cast< int >(val3);
7348 {
7349 PyThreadState* __tstate = wxPyBeginAllowThreads();
7350 {
7351 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7352 result = (wxRect *) &_result_ref;
7353 }
7354 wxPyEndAllowThreads(__tstate);
7355 if (PyErr_Occurred()) SWIG_fail;
7356 }
7357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7358 return resultobj;
7359 fail:
7360 return NULL;
7361 }
7362
7363
7364 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7365 PyObject *resultobj = 0;
7366 wxRect *arg1 = (wxRect *) 0 ;
7367 int arg2 ;
7368 int arg3 ;
7369 wxRect *result = 0 ;
7370 void *argp1 = 0 ;
7371 int res1 = 0 ;
7372 int val2 ;
7373 int ecode2 = 0 ;
7374 int val3 ;
7375 int ecode3 = 0 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 PyObject * obj2 = 0 ;
7379 char * kwnames[] = {
7380 (char *) "self",(char *) "dx",(char *) "dy", NULL
7381 };
7382
7383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7385 if (!SWIG_IsOK(res1)) {
7386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7387 }
7388 arg1 = reinterpret_cast< wxRect * >(argp1);
7389 ecode2 = SWIG_AsVal_int(obj1, &val2);
7390 if (!SWIG_IsOK(ecode2)) {
7391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7392 }
7393 arg2 = static_cast< int >(val2);
7394 ecode3 = SWIG_AsVal_int(obj2, &val3);
7395 if (!SWIG_IsOK(ecode3)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7397 }
7398 arg3 = static_cast< int >(val3);
7399 {
7400 PyThreadState* __tstate = wxPyBeginAllowThreads();
7401 {
7402 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7403 result = (wxRect *) &_result_ref;
7404 }
7405 wxPyEndAllowThreads(__tstate);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 int arg2 ;
7419 int arg3 ;
7420 void *argp1 = 0 ;
7421 int res1 = 0 ;
7422 int val2 ;
7423 int ecode2 = 0 ;
7424 int val3 ;
7425 int ecode3 = 0 ;
7426 PyObject * obj0 = 0 ;
7427 PyObject * obj1 = 0 ;
7428 PyObject * obj2 = 0 ;
7429 char * kwnames[] = {
7430 (char *) "self",(char *) "dx",(char *) "dy", NULL
7431 };
7432
7433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7435 if (!SWIG_IsOK(res1)) {
7436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7437 }
7438 arg1 = reinterpret_cast< wxRect * >(argp1);
7439 ecode2 = SWIG_AsVal_int(obj1, &val2);
7440 if (!SWIG_IsOK(ecode2)) {
7441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7442 }
7443 arg2 = static_cast< int >(val2);
7444 ecode3 = SWIG_AsVal_int(obj2, &val3);
7445 if (!SWIG_IsOK(ecode3)) {
7446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7447 }
7448 arg3 = static_cast< int >(val3);
7449 {
7450 PyThreadState* __tstate = wxPyBeginAllowThreads();
7451 (arg1)->Offset(arg2,arg3);
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 resultobj = SWIG_Py_Void();
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj = 0;
7464 wxRect *arg1 = (wxRect *) 0 ;
7465 wxPoint *arg2 = 0 ;
7466 void *argp1 = 0 ;
7467 int res1 = 0 ;
7468 wxPoint temp2 ;
7469 PyObject * obj0 = 0 ;
7470 PyObject * obj1 = 0 ;
7471 char * kwnames[] = {
7472 (char *) "self",(char *) "pt", NULL
7473 };
7474
7475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7477 if (!SWIG_IsOK(res1)) {
7478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7479 }
7480 arg1 = reinterpret_cast< wxRect * >(argp1);
7481 {
7482 arg2 = &temp2;
7483 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7484 }
7485 {
7486 PyThreadState* __tstate = wxPyBeginAllowThreads();
7487 (arg1)->Offset((wxPoint const &)*arg2);
7488 wxPyEndAllowThreads(__tstate);
7489 if (PyErr_Occurred()) SWIG_fail;
7490 }
7491 resultobj = SWIG_Py_Void();
7492 return resultobj;
7493 fail:
7494 return NULL;
7495 }
7496
7497
7498 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7499 PyObject *resultobj = 0;
7500 wxRect *arg1 = (wxRect *) 0 ;
7501 wxRect *arg2 = 0 ;
7502 wxRect result;
7503 void *argp1 = 0 ;
7504 int res1 = 0 ;
7505 wxRect temp2 ;
7506 PyObject * obj0 = 0 ;
7507 PyObject * obj1 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "rect", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7516 }
7517 arg1 = reinterpret_cast< wxRect * >(argp1);
7518 {
7519 arg2 = &temp2;
7520 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7521 }
7522 {
7523 PyThreadState* __tstate = wxPyBeginAllowThreads();
7524 result = (arg1)->Intersect((wxRect const &)*arg2);
7525 wxPyEndAllowThreads(__tstate);
7526 if (PyErr_Occurred()) SWIG_fail;
7527 }
7528 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7529 return resultobj;
7530 fail:
7531 return NULL;
7532 }
7533
7534
7535 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7536 PyObject *resultobj = 0;
7537 wxRect *arg1 = (wxRect *) 0 ;
7538 wxRect *arg2 = 0 ;
7539 wxRect result;
7540 void *argp1 = 0 ;
7541 int res1 = 0 ;
7542 wxRect temp2 ;
7543 PyObject * obj0 = 0 ;
7544 PyObject * obj1 = 0 ;
7545 char * kwnames[] = {
7546 (char *) "self",(char *) "rect", NULL
7547 };
7548
7549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7551 if (!SWIG_IsOK(res1)) {
7552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7553 }
7554 arg1 = reinterpret_cast< wxRect * >(argp1);
7555 {
7556 arg2 = &temp2;
7557 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7558 }
7559 {
7560 PyThreadState* __tstate = wxPyBeginAllowThreads();
7561 result = (arg1)->Union((wxRect const &)*arg2);
7562 wxPyEndAllowThreads(__tstate);
7563 if (PyErr_Occurred()) SWIG_fail;
7564 }
7565 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7566 return resultobj;
7567 fail:
7568 return NULL;
7569 }
7570
7571
7572 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7573 PyObject *resultobj = 0;
7574 wxRect *arg1 = (wxRect *) 0 ;
7575 wxRect *arg2 = 0 ;
7576 wxRect result;
7577 void *argp1 = 0 ;
7578 int res1 = 0 ;
7579 wxRect temp2 ;
7580 PyObject * obj0 = 0 ;
7581 PyObject * obj1 = 0 ;
7582 char * kwnames[] = {
7583 (char *) "self",(char *) "rect", NULL
7584 };
7585
7586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7588 if (!SWIG_IsOK(res1)) {
7589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7590 }
7591 arg1 = reinterpret_cast< wxRect * >(argp1);
7592 {
7593 arg2 = &temp2;
7594 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7595 }
7596 {
7597 PyThreadState* __tstate = wxPyBeginAllowThreads();
7598 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7599 wxPyEndAllowThreads(__tstate);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj = 0;
7611 wxRect *arg1 = (wxRect *) 0 ;
7612 wxRect *arg2 = 0 ;
7613 wxRect *result = 0 ;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 wxRect temp2 ;
7617 PyObject * obj0 = 0 ;
7618 PyObject * obj1 = 0 ;
7619 char * kwnames[] = {
7620 (char *) "self",(char *) "rect", NULL
7621 };
7622
7623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7627 }
7628 arg1 = reinterpret_cast< wxRect * >(argp1);
7629 {
7630 arg2 = &temp2;
7631 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7632 }
7633 {
7634 PyThreadState* __tstate = wxPyBeginAllowThreads();
7635 {
7636 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7637 result = (wxRect *) &_result_ref;
7638 }
7639 wxPyEndAllowThreads(__tstate);
7640 if (PyErr_Occurred()) SWIG_fail;
7641 }
7642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7643 return resultobj;
7644 fail:
7645 return NULL;
7646 }
7647
7648
7649 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7650 PyObject *resultobj = 0;
7651 wxRect *arg1 = (wxRect *) 0 ;
7652 PyObject *arg2 = (PyObject *) 0 ;
7653 bool result;
7654 void *argp1 = 0 ;
7655 int res1 = 0 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 char * kwnames[] = {
7659 (char *) "self",(char *) "other", NULL
7660 };
7661
7662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7666 }
7667 arg1 = reinterpret_cast< wxRect * >(argp1);
7668 arg2 = obj1;
7669 {
7670 result = (bool)wxRect___eq__(arg1,arg2);
7671 if (PyErr_Occurred()) SWIG_fail;
7672 }
7673 {
7674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7675 }
7676 return resultobj;
7677 fail:
7678 return NULL;
7679 }
7680
7681
7682 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7683 PyObject *resultobj = 0;
7684 wxRect *arg1 = (wxRect *) 0 ;
7685 PyObject *arg2 = (PyObject *) 0 ;
7686 bool result;
7687 void *argp1 = 0 ;
7688 int res1 = 0 ;
7689 PyObject * obj0 = 0 ;
7690 PyObject * obj1 = 0 ;
7691 char * kwnames[] = {
7692 (char *) "self",(char *) "other", NULL
7693 };
7694
7695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7697 if (!SWIG_IsOK(res1)) {
7698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7699 }
7700 arg1 = reinterpret_cast< wxRect * >(argp1);
7701 arg2 = obj1;
7702 {
7703 result = (bool)wxRect___ne__(arg1,arg2);
7704 if (PyErr_Occurred()) SWIG_fail;
7705 }
7706 {
7707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7708 }
7709 return resultobj;
7710 fail:
7711 return NULL;
7712 }
7713
7714
7715 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7716 PyObject *resultobj = 0;
7717 wxRect *arg1 = (wxRect *) 0 ;
7718 int arg2 ;
7719 int arg3 ;
7720 bool result;
7721 void *argp1 = 0 ;
7722 int res1 = 0 ;
7723 int val2 ;
7724 int ecode2 = 0 ;
7725 int val3 ;
7726 int ecode3 = 0 ;
7727 PyObject * obj0 = 0 ;
7728 PyObject * obj1 = 0 ;
7729 PyObject * obj2 = 0 ;
7730 char * kwnames[] = {
7731 (char *) "self",(char *) "x",(char *) "y", NULL
7732 };
7733
7734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7738 }
7739 arg1 = reinterpret_cast< wxRect * >(argp1);
7740 ecode2 = SWIG_AsVal_int(obj1, &val2);
7741 if (!SWIG_IsOK(ecode2)) {
7742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7743 }
7744 arg2 = static_cast< int >(val2);
7745 ecode3 = SWIG_AsVal_int(obj2, &val3);
7746 if (!SWIG_IsOK(ecode3)) {
7747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7748 }
7749 arg3 = static_cast< int >(val3);
7750 {
7751 PyThreadState* __tstate = wxPyBeginAllowThreads();
7752 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7753 wxPyEndAllowThreads(__tstate);
7754 if (PyErr_Occurred()) SWIG_fail;
7755 }
7756 {
7757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7758 }
7759 return resultobj;
7760 fail:
7761 return NULL;
7762 }
7763
7764
7765 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7766 PyObject *resultobj = 0;
7767 wxRect *arg1 = (wxRect *) 0 ;
7768 wxPoint *arg2 = 0 ;
7769 bool result;
7770 void *argp1 = 0 ;
7771 int res1 = 0 ;
7772 wxPoint temp2 ;
7773 PyObject * obj0 = 0 ;
7774 PyObject * obj1 = 0 ;
7775 char * kwnames[] = {
7776 (char *) "self",(char *) "pt", NULL
7777 };
7778
7779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7781 if (!SWIG_IsOK(res1)) {
7782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7783 }
7784 arg1 = reinterpret_cast< wxRect * >(argp1);
7785 {
7786 arg2 = &temp2;
7787 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7788 }
7789 {
7790 PyThreadState* __tstate = wxPyBeginAllowThreads();
7791 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7792 wxPyEndAllowThreads(__tstate);
7793 if (PyErr_Occurred()) SWIG_fail;
7794 }
7795 {
7796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7797 }
7798 return resultobj;
7799 fail:
7800 return NULL;
7801 }
7802
7803
7804 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7805 PyObject *resultobj = 0;
7806 wxRect *arg1 = (wxRect *) 0 ;
7807 wxRect *arg2 = 0 ;
7808 bool result;
7809 void *argp1 = 0 ;
7810 int res1 = 0 ;
7811 wxRect temp2 ;
7812 PyObject * obj0 = 0 ;
7813 PyObject * obj1 = 0 ;
7814 char * kwnames[] = {
7815 (char *) "self",(char *) "rect", NULL
7816 };
7817
7818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7820 if (!SWIG_IsOK(res1)) {
7821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7822 }
7823 arg1 = reinterpret_cast< wxRect * >(argp1);
7824 {
7825 arg2 = &temp2;
7826 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7827 }
7828 {
7829 PyThreadState* __tstate = wxPyBeginAllowThreads();
7830 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7831 wxPyEndAllowThreads(__tstate);
7832 if (PyErr_Occurred()) SWIG_fail;
7833 }
7834 {
7835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7836 }
7837 return resultobj;
7838 fail:
7839 return NULL;
7840 }
7841
7842
7843 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7844 PyObject *resultobj = 0;
7845 wxRect *arg1 = (wxRect *) 0 ;
7846 wxRect *arg2 = 0 ;
7847 bool result;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 wxRect temp2 ;
7851 PyObject * obj0 = 0 ;
7852 PyObject * obj1 = 0 ;
7853 char * kwnames[] = {
7854 (char *) "self",(char *) "rect", NULL
7855 };
7856
7857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7861 }
7862 arg1 = reinterpret_cast< wxRect * >(argp1);
7863 {
7864 arg2 = &temp2;
7865 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7866 }
7867 {
7868 PyThreadState* __tstate = wxPyBeginAllowThreads();
7869 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 {
7874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7875 }
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj = 0;
7884 wxRect *arg1 = (wxRect *) 0 ;
7885 wxRect *arg2 = 0 ;
7886 int arg3 = (int) wxBOTH ;
7887 wxRect result;
7888 void *argp1 = 0 ;
7889 int res1 = 0 ;
7890 wxRect temp2 ;
7891 int val3 ;
7892 int ecode3 = 0 ;
7893 PyObject * obj0 = 0 ;
7894 PyObject * obj1 = 0 ;
7895 PyObject * obj2 = 0 ;
7896 char * kwnames[] = {
7897 (char *) "self",(char *) "r",(char *) "dir", NULL
7898 };
7899
7900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7902 if (!SWIG_IsOK(res1)) {
7903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7904 }
7905 arg1 = reinterpret_cast< wxRect * >(argp1);
7906 {
7907 arg2 = &temp2;
7908 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7909 }
7910 if (obj2) {
7911 ecode3 = SWIG_AsVal_int(obj2, &val3);
7912 if (!SWIG_IsOK(ecode3)) {
7913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7914 }
7915 arg3 = static_cast< int >(val3);
7916 }
7917 {
7918 PyThreadState* __tstate = wxPyBeginAllowThreads();
7919 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7920 wxPyEndAllowThreads(__tstate);
7921 if (PyErr_Occurred()) SWIG_fail;
7922 }
7923 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 PyObject *resultobj = 0;
7932 wxRect *arg1 = (wxRect *) 0 ;
7933 int arg2 ;
7934 void *argp1 = 0 ;
7935 int res1 = 0 ;
7936 int val2 ;
7937 int ecode2 = 0 ;
7938 PyObject *swig_obj[2] ;
7939
7940 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7942 if (!SWIG_IsOK(res1)) {
7943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7944 }
7945 arg1 = reinterpret_cast< wxRect * >(argp1);
7946 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7947 if (!SWIG_IsOK(ecode2)) {
7948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7949 }
7950 arg2 = static_cast< int >(val2);
7951 if (arg1) (arg1)->x = arg2;
7952
7953 resultobj = SWIG_Py_Void();
7954 return resultobj;
7955 fail:
7956 return NULL;
7957 }
7958
7959
7960 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7961 PyObject *resultobj = 0;
7962 wxRect *arg1 = (wxRect *) 0 ;
7963 int result;
7964 void *argp1 = 0 ;
7965 int res1 = 0 ;
7966 PyObject *swig_obj[1] ;
7967
7968 if (!args) SWIG_fail;
7969 swig_obj[0] = args;
7970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7971 if (!SWIG_IsOK(res1)) {
7972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7973 }
7974 arg1 = reinterpret_cast< wxRect * >(argp1);
7975 result = (int) ((arg1)->x);
7976 resultobj = SWIG_From_int(static_cast< int >(result));
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7984 PyObject *resultobj = 0;
7985 wxRect *arg1 = (wxRect *) 0 ;
7986 int arg2 ;
7987 void *argp1 = 0 ;
7988 int res1 = 0 ;
7989 int val2 ;
7990 int ecode2 = 0 ;
7991 PyObject *swig_obj[2] ;
7992
7993 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7995 if (!SWIG_IsOK(res1)) {
7996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7997 }
7998 arg1 = reinterpret_cast< wxRect * >(argp1);
7999 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8000 if (!SWIG_IsOK(ecode2)) {
8001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8002 }
8003 arg2 = static_cast< int >(val2);
8004 if (arg1) (arg1)->y = arg2;
8005
8006 resultobj = SWIG_Py_Void();
8007 return resultobj;
8008 fail:
8009 return NULL;
8010 }
8011
8012
8013 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8014 PyObject *resultobj = 0;
8015 wxRect *arg1 = (wxRect *) 0 ;
8016 int result;
8017 void *argp1 = 0 ;
8018 int res1 = 0 ;
8019 PyObject *swig_obj[1] ;
8020
8021 if (!args) SWIG_fail;
8022 swig_obj[0] = args;
8023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8024 if (!SWIG_IsOK(res1)) {
8025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8026 }
8027 arg1 = reinterpret_cast< wxRect * >(argp1);
8028 result = (int) ((arg1)->y);
8029 resultobj = SWIG_From_int(static_cast< int >(result));
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8037 PyObject *resultobj = 0;
8038 wxRect *arg1 = (wxRect *) 0 ;
8039 int arg2 ;
8040 void *argp1 = 0 ;
8041 int res1 = 0 ;
8042 int val2 ;
8043 int ecode2 = 0 ;
8044 PyObject *swig_obj[2] ;
8045
8046 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8048 if (!SWIG_IsOK(res1)) {
8049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8050 }
8051 arg1 = reinterpret_cast< wxRect * >(argp1);
8052 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8053 if (!SWIG_IsOK(ecode2)) {
8054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8055 }
8056 arg2 = static_cast< int >(val2);
8057 if (arg1) (arg1)->width = arg2;
8058
8059 resultobj = SWIG_Py_Void();
8060 return resultobj;
8061 fail:
8062 return NULL;
8063 }
8064
8065
8066 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8067 PyObject *resultobj = 0;
8068 wxRect *arg1 = (wxRect *) 0 ;
8069 int result;
8070 void *argp1 = 0 ;
8071 int res1 = 0 ;
8072 PyObject *swig_obj[1] ;
8073
8074 if (!args) SWIG_fail;
8075 swig_obj[0] = args;
8076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8077 if (!SWIG_IsOK(res1)) {
8078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8079 }
8080 arg1 = reinterpret_cast< wxRect * >(argp1);
8081 result = (int) ((arg1)->width);
8082 resultobj = SWIG_From_int(static_cast< int >(result));
8083 return resultobj;
8084 fail:
8085 return NULL;
8086 }
8087
8088
8089 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8090 PyObject *resultobj = 0;
8091 wxRect *arg1 = (wxRect *) 0 ;
8092 int arg2 ;
8093 void *argp1 = 0 ;
8094 int res1 = 0 ;
8095 int val2 ;
8096 int ecode2 = 0 ;
8097 PyObject *swig_obj[2] ;
8098
8099 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8101 if (!SWIG_IsOK(res1)) {
8102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8103 }
8104 arg1 = reinterpret_cast< wxRect * >(argp1);
8105 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8106 if (!SWIG_IsOK(ecode2)) {
8107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8108 }
8109 arg2 = static_cast< int >(val2);
8110 if (arg1) (arg1)->height = arg2;
8111
8112 resultobj = SWIG_Py_Void();
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8120 PyObject *resultobj = 0;
8121 wxRect *arg1 = (wxRect *) 0 ;
8122 int result;
8123 void *argp1 = 0 ;
8124 int res1 = 0 ;
8125 PyObject *swig_obj[1] ;
8126
8127 if (!args) SWIG_fail;
8128 swig_obj[0] = args;
8129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8130 if (!SWIG_IsOK(res1)) {
8131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8132 }
8133 arg1 = reinterpret_cast< wxRect * >(argp1);
8134 result = (int) ((arg1)->height);
8135 resultobj = SWIG_From_int(static_cast< int >(result));
8136 return resultobj;
8137 fail:
8138 return NULL;
8139 }
8140
8141
8142 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8143 PyObject *resultobj = 0;
8144 wxRect *arg1 = (wxRect *) 0 ;
8145 int arg2 = (int) 0 ;
8146 int arg3 = (int) 0 ;
8147 int arg4 = (int) 0 ;
8148 int arg5 = (int) 0 ;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 int val2 ;
8152 int ecode2 = 0 ;
8153 int val3 ;
8154 int ecode3 = 0 ;
8155 int val4 ;
8156 int ecode4 = 0 ;
8157 int val5 ;
8158 int ecode5 = 0 ;
8159 PyObject * obj0 = 0 ;
8160 PyObject * obj1 = 0 ;
8161 PyObject * obj2 = 0 ;
8162 PyObject * obj3 = 0 ;
8163 PyObject * obj4 = 0 ;
8164 char * kwnames[] = {
8165 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8166 };
8167
8168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8170 if (!SWIG_IsOK(res1)) {
8171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8172 }
8173 arg1 = reinterpret_cast< wxRect * >(argp1);
8174 if (obj1) {
8175 ecode2 = SWIG_AsVal_int(obj1, &val2);
8176 if (!SWIG_IsOK(ecode2)) {
8177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8178 }
8179 arg2 = static_cast< int >(val2);
8180 }
8181 if (obj2) {
8182 ecode3 = SWIG_AsVal_int(obj2, &val3);
8183 if (!SWIG_IsOK(ecode3)) {
8184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8185 }
8186 arg3 = static_cast< int >(val3);
8187 }
8188 if (obj3) {
8189 ecode4 = SWIG_AsVal_int(obj3, &val4);
8190 if (!SWIG_IsOK(ecode4)) {
8191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8192 }
8193 arg4 = static_cast< int >(val4);
8194 }
8195 if (obj4) {
8196 ecode5 = SWIG_AsVal_int(obj4, &val5);
8197 if (!SWIG_IsOK(ecode5)) {
8198 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8199 }
8200 arg5 = static_cast< int >(val5);
8201 }
8202 {
8203 PyThreadState* __tstate = wxPyBeginAllowThreads();
8204 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 resultobj = SWIG_Py_Void();
8209 return resultobj;
8210 fail:
8211 return NULL;
8212 }
8213
8214
8215 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8216 PyObject *resultobj = 0;
8217 wxRect *arg1 = (wxRect *) 0 ;
8218 PyObject *result = 0 ;
8219 void *argp1 = 0 ;
8220 int res1 = 0 ;
8221 PyObject *swig_obj[1] ;
8222
8223 if (!args) SWIG_fail;
8224 swig_obj[0] = args;
8225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8226 if (!SWIG_IsOK(res1)) {
8227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8228 }
8229 arg1 = reinterpret_cast< wxRect * >(argp1);
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 result = (PyObject *)wxRect_Get(arg1);
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = result;
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8244 PyObject *obj;
8245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8246 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8247 return SWIG_Py_Void();
8248 }
8249
8250 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 return SWIG_Python_InitShadowInstance(args);
8252 }
8253
8254 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8255 PyObject *resultobj = 0;
8256 wxRect *arg1 = (wxRect *) 0 ;
8257 wxRect *arg2 = (wxRect *) 0 ;
8258 PyObject *result = 0 ;
8259 void *argp1 = 0 ;
8260 int res1 = 0 ;
8261 void *argp2 = 0 ;
8262 int res2 = 0 ;
8263 PyObject * obj0 = 0 ;
8264 PyObject * obj1 = 0 ;
8265 char * kwnames[] = {
8266 (char *) "r1",(char *) "r2", NULL
8267 };
8268
8269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8271 if (!SWIG_IsOK(res1)) {
8272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8273 }
8274 arg1 = reinterpret_cast< wxRect * >(argp1);
8275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8276 if (!SWIG_IsOK(res2)) {
8277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8278 }
8279 arg2 = reinterpret_cast< wxRect * >(argp2);
8280 {
8281 if (!wxPyCheckForApp()) SWIG_fail;
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 result = (PyObject *)wxIntersectRect(arg1,arg2);
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 resultobj = result;
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj = 0;
8296 double arg1 = (double) 0.0 ;
8297 double arg2 = (double) 0.0 ;
8298 wxPoint2D *result = 0 ;
8299 double val1 ;
8300 int ecode1 = 0 ;
8301 double val2 ;
8302 int ecode2 = 0 ;
8303 PyObject * obj0 = 0 ;
8304 PyObject * obj1 = 0 ;
8305 char * kwnames[] = {
8306 (char *) "x",(char *) "y", NULL
8307 };
8308
8309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8310 if (obj0) {
8311 ecode1 = SWIG_AsVal_double(obj0, &val1);
8312 if (!SWIG_IsOK(ecode1)) {
8313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8314 }
8315 arg1 = static_cast< double >(val1);
8316 }
8317 if (obj1) {
8318 ecode2 = SWIG_AsVal_double(obj1, &val2);
8319 if (!SWIG_IsOK(ecode2)) {
8320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8321 }
8322 arg2 = static_cast< double >(val2);
8323 }
8324 {
8325 PyThreadState* __tstate = wxPyBeginAllowThreads();
8326 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8327 wxPyEndAllowThreads(__tstate);
8328 if (PyErr_Occurred()) SWIG_fail;
8329 }
8330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8331 return resultobj;
8332 fail:
8333 return NULL;
8334 }
8335
8336
8337 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8338 PyObject *resultobj = 0;
8339 wxPoint2D *arg1 = 0 ;
8340 wxPoint2D *result = 0 ;
8341 wxPoint2D temp1 ;
8342 PyObject * obj0 = 0 ;
8343 char * kwnames[] = {
8344 (char *) "pt", NULL
8345 };
8346
8347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8348 {
8349 arg1 = &temp1;
8350 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8351 }
8352 {
8353 PyThreadState* __tstate = wxPyBeginAllowThreads();
8354 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8355 wxPyEndAllowThreads(__tstate);
8356 if (PyErr_Occurred()) SWIG_fail;
8357 }
8358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8359 return resultobj;
8360 fail:
8361 return NULL;
8362 }
8363
8364
8365 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj = 0;
8367 wxPoint *arg1 = 0 ;
8368 wxPoint2D *result = 0 ;
8369 wxPoint temp1 ;
8370 PyObject * obj0 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "pt", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8376 {
8377 arg1 = &temp1;
8378 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8379 }
8380 {
8381 PyThreadState* __tstate = wxPyBeginAllowThreads();
8382 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8383 wxPyEndAllowThreads(__tstate);
8384 if (PyErr_Occurred()) SWIG_fail;
8385 }
8386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8394 PyObject *resultobj = 0;
8395 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8396 int *arg2 = (int *) 0 ;
8397 int *arg3 = (int *) 0 ;
8398 void *argp1 = 0 ;
8399 int res1 = 0 ;
8400 int temp2 ;
8401 int res2 = SWIG_TMPOBJ ;
8402 int temp3 ;
8403 int res3 = SWIG_TMPOBJ ;
8404 PyObject *swig_obj[1] ;
8405
8406 arg2 = &temp2;
8407 arg3 = &temp3;
8408 if (!args) SWIG_fail;
8409 swig_obj[0] = args;
8410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8411 if (!SWIG_IsOK(res1)) {
8412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8413 }
8414 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8415 {
8416 PyThreadState* __tstate = wxPyBeginAllowThreads();
8417 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8418 wxPyEndAllowThreads(__tstate);
8419 if (PyErr_Occurred()) SWIG_fail;
8420 }
8421 resultobj = SWIG_Py_Void();
8422 if (SWIG_IsTmpObj(res2)) {
8423 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8424 } else {
8425 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8426 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8427 }
8428 if (SWIG_IsTmpObj(res3)) {
8429 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8430 } else {
8431 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8432 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8433 }
8434 return resultobj;
8435 fail:
8436 return NULL;
8437 }
8438
8439
8440 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8441 PyObject *resultobj = 0;
8442 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8443 int *arg2 = (int *) 0 ;
8444 int *arg3 = (int *) 0 ;
8445 void *argp1 = 0 ;
8446 int res1 = 0 ;
8447 int temp2 ;
8448 int res2 = SWIG_TMPOBJ ;
8449 int temp3 ;
8450 int res3 = SWIG_TMPOBJ ;
8451 PyObject *swig_obj[1] ;
8452
8453 arg2 = &temp2;
8454 arg3 = &temp3;
8455 if (!args) SWIG_fail;
8456 swig_obj[0] = args;
8457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8458 if (!SWIG_IsOK(res1)) {
8459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8460 }
8461 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8462 {
8463 PyThreadState* __tstate = wxPyBeginAllowThreads();
8464 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_Py_Void();
8469 if (SWIG_IsTmpObj(res2)) {
8470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8471 } else {
8472 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8474 }
8475 if (SWIG_IsTmpObj(res3)) {
8476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8477 } else {
8478 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8480 }
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 double result;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_From_double(static_cast< double >(result));
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8516 PyObject *resultobj = 0;
8517 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8518 double result;
8519 void *argp1 = 0 ;
8520 int res1 = 0 ;
8521 PyObject *swig_obj[1] ;
8522
8523 if (!args) SWIG_fail;
8524 swig_obj[0] = args;
8525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8526 if (!SWIG_IsOK(res1)) {
8527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8528 }
8529 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8530 {
8531 PyThreadState* __tstate = wxPyBeginAllowThreads();
8532 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8533 wxPyEndAllowThreads(__tstate);
8534 if (PyErr_Occurred()) SWIG_fail;
8535 }
8536 resultobj = SWIG_From_double(static_cast< double >(result));
8537 return resultobj;
8538 fail:
8539 return NULL;
8540 }
8541
8542
8543 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8544 PyObject *resultobj = 0;
8545 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8546 double arg2 ;
8547 void *argp1 = 0 ;
8548 int res1 = 0 ;
8549 double val2 ;
8550 int ecode2 = 0 ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char * kwnames[] = {
8554 (char *) "self",(char *) "length", NULL
8555 };
8556
8557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8559 if (!SWIG_IsOK(res1)) {
8560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8561 }
8562 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8563 ecode2 = SWIG_AsVal_double(obj1, &val2);
8564 if (!SWIG_IsOK(ecode2)) {
8565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8566 }
8567 arg2 = static_cast< double >(val2);
8568 {
8569 PyThreadState* __tstate = wxPyBeginAllowThreads();
8570 (arg1)->SetVectorLength(arg2);
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 resultobj = SWIG_Py_Void();
8575 return resultobj;
8576 fail:
8577 return NULL;
8578 }
8579
8580
8581 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8582 PyObject *resultobj = 0;
8583 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8584 double arg2 ;
8585 void *argp1 = 0 ;
8586 int res1 = 0 ;
8587 double val2 ;
8588 int ecode2 = 0 ;
8589 PyObject * obj0 = 0 ;
8590 PyObject * obj1 = 0 ;
8591 char * kwnames[] = {
8592 (char *) "self",(char *) "degrees", NULL
8593 };
8594
8595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8597 if (!SWIG_IsOK(res1)) {
8598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8599 }
8600 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8601 ecode2 = SWIG_AsVal_double(obj1, &val2);
8602 if (!SWIG_IsOK(ecode2)) {
8603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8604 }
8605 arg2 = static_cast< double >(val2);
8606 {
8607 PyThreadState* __tstate = wxPyBeginAllowThreads();
8608 (arg1)->SetVectorAngle(arg2);
8609 wxPyEndAllowThreads(__tstate);
8610 if (PyErr_Occurred()) SWIG_fail;
8611 }
8612 resultobj = SWIG_Py_Void();
8613 return resultobj;
8614 fail:
8615 return NULL;
8616 }
8617
8618
8619 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8620 PyObject *resultobj = 0;
8621 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8622 wxPoint2D *arg2 = 0 ;
8623 double result;
8624 void *argp1 = 0 ;
8625 int res1 = 0 ;
8626 wxPoint2D temp2 ;
8627 PyObject * obj0 = 0 ;
8628 PyObject * obj1 = 0 ;
8629 char * kwnames[] = {
8630 (char *) "self",(char *) "pt", NULL
8631 };
8632
8633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8635 if (!SWIG_IsOK(res1)) {
8636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8637 }
8638 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8639 {
8640 arg2 = &temp2;
8641 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8642 }
8643 {
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8646 wxPyEndAllowThreads(__tstate);
8647 if (PyErr_Occurred()) SWIG_fail;
8648 }
8649 resultobj = SWIG_From_double(static_cast< double >(result));
8650 return resultobj;
8651 fail:
8652 return NULL;
8653 }
8654
8655
8656 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8657 PyObject *resultobj = 0;
8658 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8659 wxPoint2D *arg2 = 0 ;
8660 double result;
8661 void *argp1 = 0 ;
8662 int res1 = 0 ;
8663 wxPoint2D temp2 ;
8664 PyObject * obj0 = 0 ;
8665 PyObject * obj1 = 0 ;
8666 char * kwnames[] = {
8667 (char *) "self",(char *) "pt", NULL
8668 };
8669
8670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8672 if (!SWIG_IsOK(res1)) {
8673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8674 }
8675 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8676 {
8677 arg2 = &temp2;
8678 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8679 }
8680 {
8681 PyThreadState* __tstate = wxPyBeginAllowThreads();
8682 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_From_double(static_cast< double >(result));
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 wxPoint2D *arg2 = 0 ;
8697 double result;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 wxPoint2D temp2 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char * kwnames[] = {
8704 (char *) "self",(char *) "vec", NULL
8705 };
8706
8707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8711 }
8712 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8713 {
8714 arg2 = &temp2;
8715 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8716 }
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8720 wxPyEndAllowThreads(__tstate);
8721 if (PyErr_Occurred()) SWIG_fail;
8722 }
8723 resultobj = SWIG_From_double(static_cast< double >(result));
8724 return resultobj;
8725 fail:
8726 return NULL;
8727 }
8728
8729
8730 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8731 PyObject *resultobj = 0;
8732 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8733 wxPoint2D *arg2 = 0 ;
8734 double result;
8735 void *argp1 = 0 ;
8736 int res1 = 0 ;
8737 wxPoint2D temp2 ;
8738 PyObject * obj0 = 0 ;
8739 PyObject * obj1 = 0 ;
8740 char * kwnames[] = {
8741 (char *) "self",(char *) "vec", NULL
8742 };
8743
8744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8746 if (!SWIG_IsOK(res1)) {
8747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8748 }
8749 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8750 {
8751 arg2 = &temp2;
8752 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8753 }
8754 {
8755 PyThreadState* __tstate = wxPyBeginAllowThreads();
8756 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8757 wxPyEndAllowThreads(__tstate);
8758 if (PyErr_Occurred()) SWIG_fail;
8759 }
8760 resultobj = SWIG_From_double(static_cast< double >(result));
8761 return resultobj;
8762 fail:
8763 return NULL;
8764 }
8765
8766
8767 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8768 PyObject *resultobj = 0;
8769 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8770 wxPoint2D result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject *swig_obj[1] ;
8774
8775 if (!args) SWIG_fail;
8776 swig_obj[0] = args;
8777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8778 if (!SWIG_IsOK(res1)) {
8779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8780 }
8781 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8782 {
8783 PyThreadState* __tstate = wxPyBeginAllowThreads();
8784 result = (arg1)->operator -();
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = 0;
8797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8798 wxPoint2D *arg2 = 0 ;
8799 wxPoint2D *result = 0 ;
8800 void *argp1 = 0 ;
8801 int res1 = 0 ;
8802 wxPoint2D temp2 ;
8803 PyObject * obj0 = 0 ;
8804 PyObject * obj1 = 0 ;
8805 char * kwnames[] = {
8806 (char *) "self",(char *) "pt", NULL
8807 };
8808
8809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8813 }
8814 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8815 {
8816 arg2 = &temp2;
8817 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8818 }
8819 {
8820 PyThreadState* __tstate = wxPyBeginAllowThreads();
8821 {
8822 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8823 result = (wxPoint2D *) &_result_ref;
8824 }
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8829 return resultobj;
8830 fail:
8831 return NULL;
8832 }
8833
8834
8835 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8836 PyObject *resultobj = 0;
8837 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8838 wxPoint2D *arg2 = 0 ;
8839 wxPoint2D *result = 0 ;
8840 void *argp1 = 0 ;
8841 int res1 = 0 ;
8842 wxPoint2D temp2 ;
8843 PyObject * obj0 = 0 ;
8844 PyObject * obj1 = 0 ;
8845 char * kwnames[] = {
8846 (char *) "self",(char *) "pt", NULL
8847 };
8848
8849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 {
8856 arg2 = &temp2;
8857 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8858 }
8859 {
8860 PyThreadState* __tstate = wxPyBeginAllowThreads();
8861 {
8862 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8863 result = (wxPoint2D *) &_result_ref;
8864 }
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj = 0;
8877 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8878 wxPoint2D *arg2 = 0 ;
8879 wxPoint2D *result = 0 ;
8880 void *argp1 = 0 ;
8881 int res1 = 0 ;
8882 wxPoint2D temp2 ;
8883 PyObject * obj0 = 0 ;
8884 PyObject * obj1 = 0 ;
8885 char * kwnames[] = {
8886 (char *) "self",(char *) "pt", NULL
8887 };
8888
8889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8891 if (!SWIG_IsOK(res1)) {
8892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8893 }
8894 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8895 {
8896 arg2 = &temp2;
8897 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8898 }
8899 {
8900 PyThreadState* __tstate = wxPyBeginAllowThreads();
8901 {
8902 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8903 result = (wxPoint2D *) &_result_ref;
8904 }
8905 wxPyEndAllowThreads(__tstate);
8906 if (PyErr_Occurred()) SWIG_fail;
8907 }
8908 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8909 return resultobj;
8910 fail:
8911 return NULL;
8912 }
8913
8914
8915 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8916 PyObject *resultobj = 0;
8917 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8918 wxPoint2D *arg2 = 0 ;
8919 wxPoint2D *result = 0 ;
8920 void *argp1 = 0 ;
8921 int res1 = 0 ;
8922 wxPoint2D temp2 ;
8923 PyObject * obj0 = 0 ;
8924 PyObject * obj1 = 0 ;
8925 char * kwnames[] = {
8926 (char *) "self",(char *) "pt", NULL
8927 };
8928
8929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8931 if (!SWIG_IsOK(res1)) {
8932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8933 }
8934 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8935 {
8936 arg2 = &temp2;
8937 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 {
8942 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8943 result = (wxPoint2D *) &_result_ref;
8944 }
8945 wxPyEndAllowThreads(__tstate);
8946 if (PyErr_Occurred()) SWIG_fail;
8947 }
8948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8949 return resultobj;
8950 fail:
8951 return NULL;
8952 }
8953
8954
8955 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj = 0;
8957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8958 PyObject *arg2 = (PyObject *) 0 ;
8959 bool result;
8960 void *argp1 = 0 ;
8961 int res1 = 0 ;
8962 PyObject * obj0 = 0 ;
8963 PyObject * obj1 = 0 ;
8964 char * kwnames[] = {
8965 (char *) "self",(char *) "other", NULL
8966 };
8967
8968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8970 if (!SWIG_IsOK(res1)) {
8971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8972 }
8973 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8974 arg2 = obj1;
8975 {
8976 result = (bool)wxPoint2D___eq__(arg1,arg2);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 {
8980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8981 }
8982 return resultobj;
8983 fail:
8984 return NULL;
8985 }
8986
8987
8988 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8989 PyObject *resultobj = 0;
8990 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8991 PyObject *arg2 = (PyObject *) 0 ;
8992 bool result;
8993 void *argp1 = 0 ;
8994 int res1 = 0 ;
8995 PyObject * obj0 = 0 ;
8996 PyObject * obj1 = 0 ;
8997 char * kwnames[] = {
8998 (char *) "self",(char *) "other", NULL
8999 };
9000
9001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9003 if (!SWIG_IsOK(res1)) {
9004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9005 }
9006 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9007 arg2 = obj1;
9008 {
9009 result = (bool)wxPoint2D___ne__(arg1,arg2);
9010 if (PyErr_Occurred()) SWIG_fail;
9011 }
9012 {
9013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9014 }
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9022 PyObject *resultobj = 0;
9023 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9024 double arg2 ;
9025 void *argp1 = 0 ;
9026 int res1 = 0 ;
9027 double val2 ;
9028 int ecode2 = 0 ;
9029 PyObject *swig_obj[2] ;
9030
9031 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9033 if (!SWIG_IsOK(res1)) {
9034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9035 }
9036 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9037 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9038 if (!SWIG_IsOK(ecode2)) {
9039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9040 }
9041 arg2 = static_cast< double >(val2);
9042 if (arg1) (arg1)->m_x = arg2;
9043
9044 resultobj = SWIG_Py_Void();
9045 return resultobj;
9046 fail:
9047 return NULL;
9048 }
9049
9050
9051 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9052 PyObject *resultobj = 0;
9053 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9054 double result;
9055 void *argp1 = 0 ;
9056 int res1 = 0 ;
9057 PyObject *swig_obj[1] ;
9058
9059 if (!args) SWIG_fail;
9060 swig_obj[0] = args;
9061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9062 if (!SWIG_IsOK(res1)) {
9063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9064 }
9065 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9066 result = (double) ((arg1)->m_x);
9067 resultobj = SWIG_From_double(static_cast< double >(result));
9068 return resultobj;
9069 fail:
9070 return NULL;
9071 }
9072
9073
9074 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9075 PyObject *resultobj = 0;
9076 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9077 double arg2 ;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 double val2 ;
9081 int ecode2 = 0 ;
9082 PyObject *swig_obj[2] ;
9083
9084 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9086 if (!SWIG_IsOK(res1)) {
9087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9088 }
9089 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9090 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9091 if (!SWIG_IsOK(ecode2)) {
9092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9093 }
9094 arg2 = static_cast< double >(val2);
9095 if (arg1) (arg1)->m_y = arg2;
9096
9097 resultobj = SWIG_Py_Void();
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105 PyObject *resultobj = 0;
9106 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9107 double result;
9108 void *argp1 = 0 ;
9109 int res1 = 0 ;
9110 PyObject *swig_obj[1] ;
9111
9112 if (!args) SWIG_fail;
9113 swig_obj[0] = args;
9114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9115 if (!SWIG_IsOK(res1)) {
9116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9117 }
9118 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9119 result = (double) ((arg1)->m_y);
9120 resultobj = SWIG_From_double(static_cast< double >(result));
9121 return resultobj;
9122 fail:
9123 return NULL;
9124 }
9125
9126
9127 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj = 0;
9129 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9130 double arg2 = (double) 0 ;
9131 double arg3 = (double) 0 ;
9132 void *argp1 = 0 ;
9133 int res1 = 0 ;
9134 double val2 ;
9135 int ecode2 = 0 ;
9136 double val3 ;
9137 int ecode3 = 0 ;
9138 PyObject * obj0 = 0 ;
9139 PyObject * obj1 = 0 ;
9140 PyObject * obj2 = 0 ;
9141 char * kwnames[] = {
9142 (char *) "self",(char *) "x",(char *) "y", NULL
9143 };
9144
9145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9147 if (!SWIG_IsOK(res1)) {
9148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9149 }
9150 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9151 if (obj1) {
9152 ecode2 = SWIG_AsVal_double(obj1, &val2);
9153 if (!SWIG_IsOK(ecode2)) {
9154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9155 }
9156 arg2 = static_cast< double >(val2);
9157 }
9158 if (obj2) {
9159 ecode3 = SWIG_AsVal_double(obj2, &val3);
9160 if (!SWIG_IsOK(ecode3)) {
9161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9162 }
9163 arg3 = static_cast< double >(val3);
9164 }
9165 {
9166 PyThreadState* __tstate = wxPyBeginAllowThreads();
9167 wxPoint2D_Set(arg1,arg2,arg3);
9168 wxPyEndAllowThreads(__tstate);
9169 if (PyErr_Occurred()) SWIG_fail;
9170 }
9171 resultobj = SWIG_Py_Void();
9172 return resultobj;
9173 fail:
9174 return NULL;
9175 }
9176
9177
9178 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9179 PyObject *resultobj = 0;
9180 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9181 PyObject *result = 0 ;
9182 void *argp1 = 0 ;
9183 int res1 = 0 ;
9184 PyObject *swig_obj[1] ;
9185
9186 if (!args) SWIG_fail;
9187 swig_obj[0] = args;
9188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9189 if (!SWIG_IsOK(res1)) {
9190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9191 }
9192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9193 {
9194 PyThreadState* __tstate = wxPyBeginAllowThreads();
9195 result = (PyObject *)wxPoint2D_Get(arg1);
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 resultobj = result;
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9207 PyObject *obj;
9208 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9209 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9210 return SWIG_Py_Void();
9211 }
9212
9213 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9214 return SWIG_Python_InitShadowInstance(args);
9215 }
9216
9217 SWIGINTERN int DefaultPosition_set(PyObject *) {
9218 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9219 return 1;
9220 }
9221
9222
9223 SWIGINTERN PyObject *DefaultPosition_get(void) {
9224 PyObject *pyobj = 0;
9225
9226 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9227 return pyobj;
9228 }
9229
9230
9231 SWIGINTERN int DefaultSize_set(PyObject *) {
9232 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9233 return 1;
9234 }
9235
9236
9237 SWIGINTERN PyObject *DefaultSize_get(void) {
9238 PyObject *pyobj = 0;
9239
9240 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9241 return pyobj;
9242 }
9243
9244
9245 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj = 0;
9247 PyObject *arg1 = (PyObject *) 0 ;
9248 wxPyInputStream *result = 0 ;
9249 PyObject * obj0 = 0 ;
9250 char * kwnames[] = {
9251 (char *) "p", NULL
9252 };
9253
9254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9255 arg1 = obj0;
9256 {
9257 PyThreadState* __tstate = wxPyBeginAllowThreads();
9258 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9263 return resultobj;
9264 fail:
9265 return NULL;
9266 }
9267
9268
9269 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9270 PyObject *resultobj = 0;
9271 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 PyObject *swig_obj[1] ;
9275
9276 if (!args) SWIG_fail;
9277 swig_obj[0] = args;
9278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9279 if (!SWIG_IsOK(res1)) {
9280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9281 }
9282 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 delete arg1;
9286
9287 wxPyEndAllowThreads(__tstate);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 resultobj = SWIG_Py_Void();
9291 return resultobj;
9292 fail:
9293 return NULL;
9294 }
9295
9296
9297 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9298 PyObject *resultobj = 0;
9299 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9300 void *argp1 = 0 ;
9301 int res1 = 0 ;
9302 PyObject *swig_obj[1] ;
9303
9304 if (!args) SWIG_fail;
9305 swig_obj[0] = args;
9306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9309 }
9310 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 (arg1)->close();
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_Py_Void();
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *resultobj = 0;
9326 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 PyObject *swig_obj[1] ;
9330
9331 if (!args) SWIG_fail;
9332 swig_obj[0] = args;
9333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9334 if (!SWIG_IsOK(res1)) {
9335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9336 }
9337 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9338 {
9339 PyThreadState* __tstate = wxPyBeginAllowThreads();
9340 (arg1)->flush();
9341 wxPyEndAllowThreads(__tstate);
9342 if (PyErr_Occurred()) SWIG_fail;
9343 }
9344 resultobj = SWIG_Py_Void();
9345 return resultobj;
9346 fail:
9347 return NULL;
9348 }
9349
9350
9351 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9352 PyObject *resultobj = 0;
9353 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9354 bool result;
9355 void *argp1 = 0 ;
9356 int res1 = 0 ;
9357 PyObject *swig_obj[1] ;
9358
9359 if (!args) SWIG_fail;
9360 swig_obj[0] = args;
9361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9362 if (!SWIG_IsOK(res1)) {
9363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9364 }
9365 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9366 {
9367 PyThreadState* __tstate = wxPyBeginAllowThreads();
9368 result = (bool)(arg1)->eof();
9369 wxPyEndAllowThreads(__tstate);
9370 if (PyErr_Occurred()) SWIG_fail;
9371 }
9372 {
9373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9374 }
9375 return resultobj;
9376 fail:
9377 return NULL;
9378 }
9379
9380
9381 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9382 PyObject *resultobj = 0;
9383 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9384 int arg2 = (int) -1 ;
9385 PyObject *result = 0 ;
9386 void *argp1 = 0 ;
9387 int res1 = 0 ;
9388 int val2 ;
9389 int ecode2 = 0 ;
9390 PyObject * obj0 = 0 ;
9391 PyObject * obj1 = 0 ;
9392 char * kwnames[] = {
9393 (char *) "self",(char *) "size", NULL
9394 };
9395
9396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9398 if (!SWIG_IsOK(res1)) {
9399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9400 }
9401 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9402 if (obj1) {
9403 ecode2 = SWIG_AsVal_int(obj1, &val2);
9404 if (!SWIG_IsOK(ecode2)) {
9405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9406 }
9407 arg2 = static_cast< int >(val2);
9408 }
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 result = (PyObject *)(arg1)->read(arg2);
9412 wxPyEndAllowThreads(__tstate);
9413 if (PyErr_Occurred()) SWIG_fail;
9414 }
9415 resultobj = result;
9416 return resultobj;
9417 fail:
9418 return NULL;
9419 }
9420
9421
9422 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9423 PyObject *resultobj = 0;
9424 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9425 int arg2 = (int) -1 ;
9426 PyObject *result = 0 ;
9427 void *argp1 = 0 ;
9428 int res1 = 0 ;
9429 int val2 ;
9430 int ecode2 = 0 ;
9431 PyObject * obj0 = 0 ;
9432 PyObject * obj1 = 0 ;
9433 char * kwnames[] = {
9434 (char *) "self",(char *) "size", NULL
9435 };
9436
9437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9439 if (!SWIG_IsOK(res1)) {
9440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9441 }
9442 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9443 if (obj1) {
9444 ecode2 = SWIG_AsVal_int(obj1, &val2);
9445 if (!SWIG_IsOK(ecode2)) {
9446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9447 }
9448 arg2 = static_cast< int >(val2);
9449 }
9450 {
9451 PyThreadState* __tstate = wxPyBeginAllowThreads();
9452 result = (PyObject *)(arg1)->readline(arg2);
9453 wxPyEndAllowThreads(__tstate);
9454 if (PyErr_Occurred()) SWIG_fail;
9455 }
9456 resultobj = result;
9457 return resultobj;
9458 fail:
9459 return NULL;
9460 }
9461
9462
9463 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9464 PyObject *resultobj = 0;
9465 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9466 int arg2 = (int) -1 ;
9467 PyObject *result = 0 ;
9468 void *argp1 = 0 ;
9469 int res1 = 0 ;
9470 int val2 ;
9471 int ecode2 = 0 ;
9472 PyObject * obj0 = 0 ;
9473 PyObject * obj1 = 0 ;
9474 char * kwnames[] = {
9475 (char *) "self",(char *) "sizehint", NULL
9476 };
9477
9478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9480 if (!SWIG_IsOK(res1)) {
9481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9482 }
9483 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9484 if (obj1) {
9485 ecode2 = SWIG_AsVal_int(obj1, &val2);
9486 if (!SWIG_IsOK(ecode2)) {
9487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9488 }
9489 arg2 = static_cast< int >(val2);
9490 }
9491 {
9492 PyThreadState* __tstate = wxPyBeginAllowThreads();
9493 result = (PyObject *)(arg1)->readlines(arg2);
9494 wxPyEndAllowThreads(__tstate);
9495 if (PyErr_Occurred()) SWIG_fail;
9496 }
9497 resultobj = result;
9498 return resultobj;
9499 fail:
9500 return NULL;
9501 }
9502
9503
9504 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj = 0;
9506 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9507 int arg2 ;
9508 int arg3 = (int) 0 ;
9509 void *argp1 = 0 ;
9510 int res1 = 0 ;
9511 int val2 ;
9512 int ecode2 = 0 ;
9513 int val3 ;
9514 int ecode3 = 0 ;
9515 PyObject * obj0 = 0 ;
9516 PyObject * obj1 = 0 ;
9517 PyObject * obj2 = 0 ;
9518 char * kwnames[] = {
9519 (char *) "self",(char *) "offset",(char *) "whence", NULL
9520 };
9521
9522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9526 }
9527 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9528 ecode2 = SWIG_AsVal_int(obj1, &val2);
9529 if (!SWIG_IsOK(ecode2)) {
9530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9531 }
9532 arg2 = static_cast< int >(val2);
9533 if (obj2) {
9534 ecode3 = SWIG_AsVal_int(obj2, &val3);
9535 if (!SWIG_IsOK(ecode3)) {
9536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9537 }
9538 arg3 = static_cast< int >(val3);
9539 }
9540 {
9541 PyThreadState* __tstate = wxPyBeginAllowThreads();
9542 (arg1)->seek(arg2,arg3);
9543 wxPyEndAllowThreads(__tstate);
9544 if (PyErr_Occurred()) SWIG_fail;
9545 }
9546 resultobj = SWIG_Py_Void();
9547 return resultobj;
9548 fail:
9549 return NULL;
9550 }
9551
9552
9553 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9554 PyObject *resultobj = 0;
9555 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9556 int result;
9557 void *argp1 = 0 ;
9558 int res1 = 0 ;
9559 PyObject *swig_obj[1] ;
9560
9561 if (!args) SWIG_fail;
9562 swig_obj[0] = args;
9563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9564 if (!SWIG_IsOK(res1)) {
9565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9566 }
9567 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9568 {
9569 PyThreadState* __tstate = wxPyBeginAllowThreads();
9570 result = (int)(arg1)->tell();
9571 wxPyEndAllowThreads(__tstate);
9572 if (PyErr_Occurred()) SWIG_fail;
9573 }
9574 resultobj = SWIG_From_int(static_cast< int >(result));
9575 return resultobj;
9576 fail:
9577 return NULL;
9578 }
9579
9580
9581 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9582 PyObject *resultobj = 0;
9583 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9584 char result;
9585 void *argp1 = 0 ;
9586 int res1 = 0 ;
9587 PyObject *swig_obj[1] ;
9588
9589 if (!args) SWIG_fail;
9590 swig_obj[0] = args;
9591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9592 if (!SWIG_IsOK(res1)) {
9593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9594 }
9595 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9596 {
9597 PyThreadState* __tstate = wxPyBeginAllowThreads();
9598 result = (char)(arg1)->Peek();
9599 wxPyEndAllowThreads(__tstate);
9600 if (PyErr_Occurred()) SWIG_fail;
9601 }
9602 resultobj = SWIG_From_char(static_cast< char >(result));
9603 return resultobj;
9604 fail:
9605 return NULL;
9606 }
9607
9608
9609 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9610 PyObject *resultobj = 0;
9611 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9612 char result;
9613 void *argp1 = 0 ;
9614 int res1 = 0 ;
9615 PyObject *swig_obj[1] ;
9616
9617 if (!args) SWIG_fail;
9618 swig_obj[0] = args;
9619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9620 if (!SWIG_IsOK(res1)) {
9621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9622 }
9623 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9624 {
9625 PyThreadState* __tstate = wxPyBeginAllowThreads();
9626 result = (char)(arg1)->GetC();
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 resultobj = SWIG_From_char(static_cast< char >(result));
9631 return resultobj;
9632 fail:
9633 return NULL;
9634 }
9635
9636
9637 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9638 PyObject *resultobj = 0;
9639 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9640 size_t result;
9641 void *argp1 = 0 ;
9642 int res1 = 0 ;
9643 PyObject *swig_obj[1] ;
9644
9645 if (!args) SWIG_fail;
9646 swig_obj[0] = args;
9647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 result = (size_t)(arg1)->LastRead();
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9666 PyObject *resultobj = 0;
9667 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9668 bool result;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9678 }
9679 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (bool)(arg1)->CanRead();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 {
9687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9688 }
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *_wrap_InputStream_Eof(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_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9708 }
9709 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9710 {
9711 PyThreadState* __tstate = wxPyBeginAllowThreads();
9712 result = (bool)(arg1)->Eof();
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_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9726 PyObject *resultobj = 0;
9727 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9728 char arg2 ;
9729 bool result;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 char val2 ;
9733 int ecode2 = 0 ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 char * kwnames[] = {
9737 (char *) "self",(char *) "c", NULL
9738 };
9739
9740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9742 if (!SWIG_IsOK(res1)) {
9743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9744 }
9745 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9746 ecode2 = SWIG_AsVal_char(obj1, &val2);
9747 if (!SWIG_IsOK(ecode2)) {
9748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9749 }
9750 arg2 = static_cast< char >(val2);
9751 {
9752 PyThreadState* __tstate = wxPyBeginAllowThreads();
9753 result = (bool)(arg1)->Ungetch(arg2);
9754 wxPyEndAllowThreads(__tstate);
9755 if (PyErr_Occurred()) SWIG_fail;
9756 }
9757 {
9758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9759 }
9760 return resultobj;
9761 fail:
9762 return NULL;
9763 }
9764
9765
9766 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj = 0;
9768 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9769 long arg2 ;
9770 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9771 long result;
9772 void *argp1 = 0 ;
9773 int res1 = 0 ;
9774 long val2 ;
9775 int ecode2 = 0 ;
9776 int val3 ;
9777 int ecode3 = 0 ;
9778 PyObject * obj0 = 0 ;
9779 PyObject * obj1 = 0 ;
9780 PyObject * obj2 = 0 ;
9781 char * kwnames[] = {
9782 (char *) "self",(char *) "pos",(char *) "mode", NULL
9783 };
9784
9785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9787 if (!SWIG_IsOK(res1)) {
9788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9789 }
9790 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9791 ecode2 = SWIG_AsVal_long(obj1, &val2);
9792 if (!SWIG_IsOK(ecode2)) {
9793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9794 }
9795 arg2 = static_cast< long >(val2);
9796 if (obj2) {
9797 ecode3 = SWIG_AsVal_int(obj2, &val3);
9798 if (!SWIG_IsOK(ecode3)) {
9799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9800 }
9801 arg3 = static_cast< wxSeekMode >(val3);
9802 }
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 result = (long)(arg1)->SeekI(arg2,arg3);
9806 wxPyEndAllowThreads(__tstate);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 resultobj = SWIG_From_long(static_cast< long >(result));
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *resultobj = 0;
9818 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9819 long result;
9820 void *argp1 = 0 ;
9821 int res1 = 0 ;
9822 PyObject *swig_obj[1] ;
9823
9824 if (!args) SWIG_fail;
9825 swig_obj[0] = args;
9826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9829 }
9830 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9831 {
9832 PyThreadState* __tstate = wxPyBeginAllowThreads();
9833 result = (long)(arg1)->TellI();
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 resultobj = SWIG_From_long(static_cast< long >(result));
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9845 PyObject *obj;
9846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9847 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9848 return SWIG_Py_Void();
9849 }
9850
9851 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9852 return SWIG_Python_InitShadowInstance(args);
9853 }
9854
9855 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9856 PyObject *resultobj = 0;
9857 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9858 PyObject *arg2 = (PyObject *) 0 ;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject * obj0 = 0 ;
9862 PyObject * obj1 = 0 ;
9863 char * kwnames[] = {
9864 (char *) "self",(char *) "obj", NULL
9865 };
9866
9867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9869 if (!SWIG_IsOK(res1)) {
9870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9871 }
9872 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9873 arg2 = obj1;
9874 {
9875 PyThreadState* __tstate = wxPyBeginAllowThreads();
9876 wxOutputStream_write(arg1,arg2);
9877 wxPyEndAllowThreads(__tstate);
9878 if (PyErr_Occurred()) SWIG_fail;
9879 }
9880 resultobj = SWIG_Py_Void();
9881 return resultobj;
9882 fail:
9883 return NULL;
9884 }
9885
9886
9887 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9888 PyObject *resultobj = 0;
9889 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9890 size_t result;
9891 void *argp1 = 0 ;
9892 int res1 = 0 ;
9893 PyObject *swig_obj[1] ;
9894
9895 if (!args) SWIG_fail;
9896 swig_obj[0] = args;
9897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9898 if (!SWIG_IsOK(res1)) {
9899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9900 }
9901 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9902 {
9903 PyThreadState* __tstate = wxPyBeginAllowThreads();
9904 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9916 PyObject *obj;
9917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9918 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9919 return SWIG_Py_Void();
9920 }
9921
9922 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9923 PyObject *resultobj = 0;
9924 wxInputStream *arg1 = (wxInputStream *) 0 ;
9925 wxString *arg2 = 0 ;
9926 wxString *arg3 = 0 ;
9927 wxString *arg4 = 0 ;
9928 wxDateTime arg5 ;
9929 wxFSFile *result = 0 ;
9930 wxPyInputStream *temp1 ;
9931 bool temp2 = false ;
9932 bool temp3 = false ;
9933 bool temp4 = false ;
9934 void *argp5 ;
9935 int res5 = 0 ;
9936 PyObject * obj0 = 0 ;
9937 PyObject * obj1 = 0 ;
9938 PyObject * obj2 = 0 ;
9939 PyObject * obj3 = 0 ;
9940 PyObject * obj4 = 0 ;
9941 char * kwnames[] = {
9942 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9943 };
9944
9945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9946 {
9947 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9948 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9949 } else {
9950 PyErr_Clear(); // clear the failure of the wxPyConvert above
9951 arg1 = wxPyCBInputStream_create(obj0, true);
9952 if (arg1 == NULL) {
9953 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9954 SWIG_fail;
9955 }
9956 }
9957 }
9958 {
9959 arg2 = wxString_in_helper(obj1);
9960 if (arg2 == NULL) SWIG_fail;
9961 temp2 = true;
9962 }
9963 {
9964 arg3 = wxString_in_helper(obj2);
9965 if (arg3 == NULL) SWIG_fail;
9966 temp3 = true;
9967 }
9968 {
9969 arg4 = wxString_in_helper(obj3);
9970 if (arg4 == NULL) SWIG_fail;
9971 temp4 = true;
9972 }
9973 {
9974 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9975 if (!SWIG_IsOK(res5)) {
9976 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9977 }
9978 if (!argp5) {
9979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9980 } else {
9981 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9982 arg5 = *temp;
9983 if (SWIG_IsNewObj(res5)) delete temp;
9984 }
9985 }
9986 {
9987 PyThreadState* __tstate = wxPyBeginAllowThreads();
9988 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9989 wxPyEndAllowThreads(__tstate);
9990 if (PyErr_Occurred()) SWIG_fail;
9991 }
9992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9993 {
9994 if (temp2)
9995 delete arg2;
9996 }
9997 {
9998 if (temp3)
9999 delete arg3;
10000 }
10001 {
10002 if (temp4)
10003 delete arg4;
10004 }
10005 return resultobj;
10006 fail:
10007 {
10008 if (temp2)
10009 delete arg2;
10010 }
10011 {
10012 if (temp3)
10013 delete arg3;
10014 }
10015 {
10016 if (temp4)
10017 delete arg4;
10018 }
10019 return NULL;
10020 }
10021
10022
10023 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10024 PyObject *resultobj = 0;
10025 wxFSFile *arg1 = (wxFSFile *) 0 ;
10026 void *argp1 = 0 ;
10027 int res1 = 0 ;
10028 PyObject *swig_obj[1] ;
10029
10030 if (!args) SWIG_fail;
10031 swig_obj[0] = args;
10032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10033 if (!SWIG_IsOK(res1)) {
10034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10035 }
10036 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10037 {
10038 PyThreadState* __tstate = wxPyBeginAllowThreads();
10039 delete arg1;
10040
10041 wxPyEndAllowThreads(__tstate);
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 resultobj = SWIG_Py_Void();
10045 return resultobj;
10046 fail:
10047 return NULL;
10048 }
10049
10050
10051 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10052 PyObject *resultobj = 0;
10053 wxFSFile *arg1 = (wxFSFile *) 0 ;
10054 wxInputStream *result = 0 ;
10055 void *argp1 = 0 ;
10056 int res1 = 0 ;
10057 PyObject *swig_obj[1] ;
10058
10059 if (!args) SWIG_fail;
10060 swig_obj[0] = args;
10061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10062 if (!SWIG_IsOK(res1)) {
10063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10064 }
10065 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10066 {
10067 PyThreadState* __tstate = wxPyBeginAllowThreads();
10068 result = (wxInputStream *)(arg1)->GetStream();
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 {
10073 wxPyInputStream * _ptr = NULL;
10074
10075 if (result) {
10076 _ptr = new wxPyInputStream(result);
10077 }
10078 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10079 }
10080 return resultobj;
10081 fail:
10082 return NULL;
10083 }
10084
10085
10086 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10087 PyObject *resultobj = 0;
10088 wxFSFile *arg1 = (wxFSFile *) 0 ;
10089 void *argp1 = 0 ;
10090 int res1 = 0 ;
10091 PyObject *swig_obj[1] ;
10092
10093 if (!args) SWIG_fail;
10094 swig_obj[0] = args;
10095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10096 if (!SWIG_IsOK(res1)) {
10097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10098 }
10099 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10100 {
10101 PyThreadState* __tstate = wxPyBeginAllowThreads();
10102 (arg1)->DetachStream();
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 resultobj = SWIG_Py_Void();
10107 return resultobj;
10108 fail:
10109 return NULL;
10110 }
10111
10112
10113 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10114 PyObject *resultobj = 0;
10115 wxFSFile *arg1 = (wxFSFile *) 0 ;
10116 wxString *result = 0 ;
10117 void *argp1 = 0 ;
10118 int res1 = 0 ;
10119 PyObject *swig_obj[1] ;
10120
10121 if (!args) SWIG_fail;
10122 swig_obj[0] = args;
10123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10124 if (!SWIG_IsOK(res1)) {
10125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10126 }
10127 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 {
10131 wxString const &_result_ref = (arg1)->GetMimeType();
10132 result = (wxString *) &_result_ref;
10133 }
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 {
10138 #if wxUSE_UNICODE
10139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10140 #else
10141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10142 #endif
10143 }
10144 return resultobj;
10145 fail:
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10151 PyObject *resultobj = 0;
10152 wxFSFile *arg1 = (wxFSFile *) 0 ;
10153 wxString *result = 0 ;
10154 void *argp1 = 0 ;
10155 int res1 = 0 ;
10156 PyObject *swig_obj[1] ;
10157
10158 if (!args) SWIG_fail;
10159 swig_obj[0] = args;
10160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10161 if (!SWIG_IsOK(res1)) {
10162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10163 }
10164 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 {
10168 wxString const &_result_ref = (arg1)->GetLocation();
10169 result = (wxString *) &_result_ref;
10170 }
10171 wxPyEndAllowThreads(__tstate);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 {
10175 #if wxUSE_UNICODE
10176 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10177 #else
10178 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10179 #endif
10180 }
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10188 PyObject *resultobj = 0;
10189 wxFSFile *arg1 = (wxFSFile *) 0 ;
10190 wxString *result = 0 ;
10191 void *argp1 = 0 ;
10192 int res1 = 0 ;
10193 PyObject *swig_obj[1] ;
10194
10195 if (!args) SWIG_fail;
10196 swig_obj[0] = args;
10197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10198 if (!SWIG_IsOK(res1)) {
10199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10200 }
10201 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 {
10205 wxString const &_result_ref = (arg1)->GetAnchor();
10206 result = (wxString *) &_result_ref;
10207 }
10208 wxPyEndAllowThreads(__tstate);
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 {
10212 #if wxUSE_UNICODE
10213 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10214 #else
10215 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10216 #endif
10217 }
10218 return resultobj;
10219 fail:
10220 return NULL;
10221 }
10222
10223
10224 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10225 PyObject *resultobj = 0;
10226 wxFSFile *arg1 = (wxFSFile *) 0 ;
10227 wxDateTime result;
10228 void *argp1 = 0 ;
10229 int res1 = 0 ;
10230 PyObject *swig_obj[1] ;
10231
10232 if (!args) SWIG_fail;
10233 swig_obj[0] = args;
10234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10235 if (!SWIG_IsOK(res1)) {
10236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10237 }
10238 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10239 {
10240 PyThreadState* __tstate = wxPyBeginAllowThreads();
10241 result = (arg1)->GetModificationTime();
10242 wxPyEndAllowThreads(__tstate);
10243 if (PyErr_Occurred()) SWIG_fail;
10244 }
10245 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10246 return resultobj;
10247 fail:
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10253 PyObject *obj;
10254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10255 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10256 return SWIG_Py_Void();
10257 }
10258
10259 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10260 return SWIG_Python_InitShadowInstance(args);
10261 }
10262
10263 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10264 PyObject *resultobj = 0;
10265 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10266 void *argp1 = 0 ;
10267 int res1 = 0 ;
10268 PyObject *swig_obj[1] ;
10269
10270 if (!args) SWIG_fail;
10271 swig_obj[0] = args;
10272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10273 if (!SWIG_IsOK(res1)) {
10274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10275 }
10276 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 delete arg1;
10280
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 resultobj = SWIG_Py_Void();
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10292 PyObject *obj;
10293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10294 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10295 return SWIG_Py_Void();
10296 }
10297
10298 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10299 PyObject *resultobj = 0;
10300 wxPyFileSystemHandler *result = 0 ;
10301
10302 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10303 {
10304 PyThreadState* __tstate = wxPyBeginAllowThreads();
10305 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10306 wxPyEndAllowThreads(__tstate);
10307 if (PyErr_Occurred()) SWIG_fail;
10308 }
10309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10310 return resultobj;
10311 fail:
10312 return NULL;
10313 }
10314
10315
10316 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10317 PyObject *resultobj = 0;
10318 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10319 PyObject *arg2 = (PyObject *) 0 ;
10320 PyObject *arg3 = (PyObject *) 0 ;
10321 void *argp1 = 0 ;
10322 int res1 = 0 ;
10323 PyObject * obj0 = 0 ;
10324 PyObject * obj1 = 0 ;
10325 PyObject * obj2 = 0 ;
10326 char * kwnames[] = {
10327 (char *) "self",(char *) "self",(char *) "_class", NULL
10328 };
10329
10330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10332 if (!SWIG_IsOK(res1)) {
10333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10334 }
10335 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10336 arg2 = obj1;
10337 arg3 = obj2;
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 (arg1)->_setCallbackInfo(arg2,arg3);
10341 wxPyEndAllowThreads(__tstate);
10342 if (PyErr_Occurred()) SWIG_fail;
10343 }
10344 resultobj = SWIG_Py_Void();
10345 return resultobj;
10346 fail:
10347 return NULL;
10348 }
10349
10350
10351 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10352 PyObject *resultobj = 0;
10353 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10354 wxString *arg2 = 0 ;
10355 bool result;
10356 void *argp1 = 0 ;
10357 int res1 = 0 ;
10358 bool temp2 = false ;
10359 PyObject * obj0 = 0 ;
10360 PyObject * obj1 = 0 ;
10361 char * kwnames[] = {
10362 (char *) "self",(char *) "location", NULL
10363 };
10364
10365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10367 if (!SWIG_IsOK(res1)) {
10368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10369 }
10370 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10371 {
10372 arg2 = wxString_in_helper(obj1);
10373 if (arg2 == NULL) SWIG_fail;
10374 temp2 = true;
10375 }
10376 {
10377 PyThreadState* __tstate = wxPyBeginAllowThreads();
10378 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10379 wxPyEndAllowThreads(__tstate);
10380 if (PyErr_Occurred()) SWIG_fail;
10381 }
10382 {
10383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10384 }
10385 {
10386 if (temp2)
10387 delete arg2;
10388 }
10389 return resultobj;
10390 fail:
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return NULL;
10396 }
10397
10398
10399 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10400 PyObject *resultobj = 0;
10401 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10402 wxFileSystem *arg2 = 0 ;
10403 wxString *arg3 = 0 ;
10404 wxFSFile *result = 0 ;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 void *argp2 = 0 ;
10408 int res2 = 0 ;
10409 bool temp3 = false ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 PyObject * obj2 = 0 ;
10413 char * kwnames[] = {
10414 (char *) "self",(char *) "fs",(char *) "location", NULL
10415 };
10416
10417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10421 }
10422 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10423 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10424 if (!SWIG_IsOK(res2)) {
10425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10426 }
10427 if (!argp2) {
10428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10429 }
10430 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10431 {
10432 arg3 = wxString_in_helper(obj2);
10433 if (arg3 == NULL) SWIG_fail;
10434 temp3 = true;
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 {
10443 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10444 }
10445 {
10446 if (temp3)
10447 delete arg3;
10448 }
10449 return resultobj;
10450 fail:
10451 {
10452 if (temp3)
10453 delete arg3;
10454 }
10455 return NULL;
10456 }
10457
10458
10459 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10460 PyObject *resultobj = 0;
10461 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10462 wxString *arg2 = 0 ;
10463 int arg3 = (int) 0 ;
10464 wxString result;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 bool temp2 = false ;
10468 int val3 ;
10469 int ecode3 = 0 ;
10470 PyObject * obj0 = 0 ;
10471 PyObject * obj1 = 0 ;
10472 PyObject * obj2 = 0 ;
10473 char * kwnames[] = {
10474 (char *) "self",(char *) "spec",(char *) "flags", NULL
10475 };
10476
10477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10481 }
10482 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10483 {
10484 arg2 = wxString_in_helper(obj1);
10485 if (arg2 == NULL) SWIG_fail;
10486 temp2 = true;
10487 }
10488 if (obj2) {
10489 ecode3 = SWIG_AsVal_int(obj2, &val3);
10490 if (!SWIG_IsOK(ecode3)) {
10491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10492 }
10493 arg3 = static_cast< int >(val3);
10494 }
10495 {
10496 PyThreadState* __tstate = wxPyBeginAllowThreads();
10497 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10498 wxPyEndAllowThreads(__tstate);
10499 if (PyErr_Occurred()) SWIG_fail;
10500 }
10501 {
10502 #if wxUSE_UNICODE
10503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10504 #else
10505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10506 #endif
10507 }
10508 {
10509 if (temp2)
10510 delete arg2;
10511 }
10512 return resultobj;
10513 fail:
10514 {
10515 if (temp2)
10516 delete arg2;
10517 }
10518 return NULL;
10519 }
10520
10521
10522 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10523 PyObject *resultobj = 0;
10524 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10525 wxString result;
10526 void *argp1 = 0 ;
10527 int res1 = 0 ;
10528 PyObject *swig_obj[1] ;
10529
10530 if (!args) SWIG_fail;
10531 swig_obj[0] = args;
10532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10533 if (!SWIG_IsOK(res1)) {
10534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10535 }
10536 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 result = (arg1)->FindNext();
10540 wxPyEndAllowThreads(__tstate);
10541 if (PyErr_Occurred()) SWIG_fail;
10542 }
10543 {
10544 #if wxUSE_UNICODE
10545 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10546 #else
10547 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10548 #endif
10549 }
10550 return resultobj;
10551 fail:
10552 return NULL;
10553 }
10554
10555
10556 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10557 PyObject *resultobj = 0;
10558 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10559 wxString *arg2 = 0 ;
10560 wxString result;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 bool temp2 = false ;
10564 PyObject * obj0 = 0 ;
10565 PyObject * obj1 = 0 ;
10566 char * kwnames[] = {
10567 (char *) "self",(char *) "location", NULL
10568 };
10569
10570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10572 if (!SWIG_IsOK(res1)) {
10573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10574 }
10575 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10576 {
10577 arg2 = wxString_in_helper(obj1);
10578 if (arg2 == NULL) SWIG_fail;
10579 temp2 = true;
10580 }
10581 {
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 result = (arg1)->GetProtocol((wxString const &)*arg2);
10584 wxPyEndAllowThreads(__tstate);
10585 if (PyErr_Occurred()) SWIG_fail;
10586 }
10587 {
10588 #if wxUSE_UNICODE
10589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10590 #else
10591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10592 #endif
10593 }
10594 {
10595 if (temp2)
10596 delete arg2;
10597 }
10598 return resultobj;
10599 fail:
10600 {
10601 if (temp2)
10602 delete arg2;
10603 }
10604 return NULL;
10605 }
10606
10607
10608 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10609 PyObject *resultobj = 0;
10610 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10611 wxString *arg2 = 0 ;
10612 wxString result;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 bool temp2 = false ;
10616 PyObject * obj0 = 0 ;
10617 PyObject * obj1 = 0 ;
10618 char * kwnames[] = {
10619 (char *) "self",(char *) "location", NULL
10620 };
10621
10622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10624 if (!SWIG_IsOK(res1)) {
10625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10626 }
10627 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10628 {
10629 arg2 = wxString_in_helper(obj1);
10630 if (arg2 == NULL) SWIG_fail;
10631 temp2 = true;
10632 }
10633 {
10634 PyThreadState* __tstate = wxPyBeginAllowThreads();
10635 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10636 wxPyEndAllowThreads(__tstate);
10637 if (PyErr_Occurred()) SWIG_fail;
10638 }
10639 {
10640 #if wxUSE_UNICODE
10641 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10642 #else
10643 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10644 #endif
10645 }
10646 {
10647 if (temp2)
10648 delete arg2;
10649 }
10650 return resultobj;
10651 fail:
10652 {
10653 if (temp2)
10654 delete arg2;
10655 }
10656 return NULL;
10657 }
10658
10659
10660 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj = 0;
10662 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10663 wxString *arg2 = 0 ;
10664 wxString result;
10665 void *argp1 = 0 ;
10666 int res1 = 0 ;
10667 bool temp2 = false ;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 char * kwnames[] = {
10671 (char *) "self",(char *) "location", NULL
10672 };
10673
10674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10676 if (!SWIG_IsOK(res1)) {
10677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10678 }
10679 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10680 {
10681 arg2 = wxString_in_helper(obj1);
10682 if (arg2 == NULL) SWIG_fail;
10683 temp2 = true;
10684 }
10685 {
10686 PyThreadState* __tstate = wxPyBeginAllowThreads();
10687 result = (arg1)->GetAnchor((wxString const &)*arg2);
10688 wxPyEndAllowThreads(__tstate);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 {
10692 #if wxUSE_UNICODE
10693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10694 #else
10695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10696 #endif
10697 }
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return resultobj;
10703 fail:
10704 {
10705 if (temp2)
10706 delete arg2;
10707 }
10708 return NULL;
10709 }
10710
10711
10712 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10713 PyObject *resultobj = 0;
10714 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10715 wxString *arg2 = 0 ;
10716 wxString result;
10717 void *argp1 = 0 ;
10718 int res1 = 0 ;
10719 bool temp2 = false ;
10720 PyObject * obj0 = 0 ;
10721 PyObject * obj1 = 0 ;
10722 char * kwnames[] = {
10723 (char *) "self",(char *) "location", NULL
10724 };
10725
10726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10728 if (!SWIG_IsOK(res1)) {
10729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10730 }
10731 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10732 {
10733 arg2 = wxString_in_helper(obj1);
10734 if (arg2 == NULL) SWIG_fail;
10735 temp2 = true;
10736 }
10737 {
10738 PyThreadState* __tstate = wxPyBeginAllowThreads();
10739 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10740 wxPyEndAllowThreads(__tstate);
10741 if (PyErr_Occurred()) SWIG_fail;
10742 }
10743 {
10744 #if wxUSE_UNICODE
10745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10746 #else
10747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10748 #endif
10749 }
10750 {
10751 if (temp2)
10752 delete arg2;
10753 }
10754 return resultobj;
10755 fail:
10756 {
10757 if (temp2)
10758 delete arg2;
10759 }
10760 return NULL;
10761 }
10762
10763
10764 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj = 0;
10766 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10767 wxString *arg2 = 0 ;
10768 wxString result;
10769 void *argp1 = 0 ;
10770 int res1 = 0 ;
10771 bool temp2 = false ;
10772 PyObject * obj0 = 0 ;
10773 PyObject * obj1 = 0 ;
10774 char * kwnames[] = {
10775 (char *) "self",(char *) "location", NULL
10776 };
10777
10778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10780 if (!SWIG_IsOK(res1)) {
10781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10782 }
10783 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10784 {
10785 arg2 = wxString_in_helper(obj1);
10786 if (arg2 == NULL) SWIG_fail;
10787 temp2 = true;
10788 }
10789 {
10790 PyThreadState* __tstate = wxPyBeginAllowThreads();
10791 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 {
10796 #if wxUSE_UNICODE
10797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10798 #else
10799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10800 #endif
10801 }
10802 {
10803 if (temp2)
10804 delete arg2;
10805 }
10806 return resultobj;
10807 fail:
10808 {
10809 if (temp2)
10810 delete arg2;
10811 }
10812 return NULL;
10813 }
10814
10815
10816 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10817 PyObject *obj;
10818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10819 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10820 return SWIG_Py_Void();
10821 }
10822
10823 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10824 return SWIG_Python_InitShadowInstance(args);
10825 }
10826
10827 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10828 PyObject *resultobj = 0;
10829 wxFileSystem *result = 0 ;
10830
10831 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = (wxFileSystem *)new wxFileSystem();
10835 wxPyEndAllowThreads(__tstate);
10836 if (PyErr_Occurred()) SWIG_fail;
10837 }
10838 {
10839 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10840 }
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10848 PyObject *resultobj = 0;
10849 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10850 void *argp1 = 0 ;
10851 int res1 = 0 ;
10852 PyObject *swig_obj[1] ;
10853
10854 if (!args) SWIG_fail;
10855 swig_obj[0] = args;
10856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10857 if (!SWIG_IsOK(res1)) {
10858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10859 }
10860 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10861 {
10862 PyThreadState* __tstate = wxPyBeginAllowThreads();
10863 delete arg1;
10864
10865 wxPyEndAllowThreads(__tstate);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 resultobj = SWIG_Py_Void();
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10878 wxString *arg2 = 0 ;
10879 bool arg3 = (bool) false ;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 bool temp2 = false ;
10883 bool val3 ;
10884 int ecode3 = 0 ;
10885 PyObject * obj0 = 0 ;
10886 PyObject * obj1 = 0 ;
10887 PyObject * obj2 = 0 ;
10888 char * kwnames[] = {
10889 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10890 };
10891
10892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10894 if (!SWIG_IsOK(res1)) {
10895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10896 }
10897 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10898 {
10899 arg2 = wxString_in_helper(obj1);
10900 if (arg2 == NULL) SWIG_fail;
10901 temp2 = true;
10902 }
10903 if (obj2) {
10904 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10905 if (!SWIG_IsOK(ecode3)) {
10906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10907 }
10908 arg3 = static_cast< bool >(val3);
10909 }
10910 {
10911 PyThreadState* __tstate = wxPyBeginAllowThreads();
10912 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10913 wxPyEndAllowThreads(__tstate);
10914 if (PyErr_Occurred()) SWIG_fail;
10915 }
10916 resultobj = SWIG_Py_Void();
10917 {
10918 if (temp2)
10919 delete arg2;
10920 }
10921 return resultobj;
10922 fail:
10923 {
10924 if (temp2)
10925 delete arg2;
10926 }
10927 return NULL;
10928 }
10929
10930
10931 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10932 PyObject *resultobj = 0;
10933 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10934 wxString result;
10935 void *argp1 = 0 ;
10936 int res1 = 0 ;
10937 PyObject *swig_obj[1] ;
10938
10939 if (!args) SWIG_fail;
10940 swig_obj[0] = args;
10941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10942 if (!SWIG_IsOK(res1)) {
10943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10944 }
10945 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 result = (arg1)->GetPath();
10949 wxPyEndAllowThreads(__tstate);
10950 if (PyErr_Occurred()) SWIG_fail;
10951 }
10952 {
10953 #if wxUSE_UNICODE
10954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10955 #else
10956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10957 #endif
10958 }
10959 return resultobj;
10960 fail:
10961 return NULL;
10962 }
10963
10964
10965 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10966 PyObject *resultobj = 0;
10967 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10968 wxString *arg2 = 0 ;
10969 wxFSFile *result = 0 ;
10970 void *argp1 = 0 ;
10971 int res1 = 0 ;
10972 bool temp2 = false ;
10973 PyObject * obj0 = 0 ;
10974 PyObject * obj1 = 0 ;
10975 char * kwnames[] = {
10976 (char *) "self",(char *) "location", NULL
10977 };
10978
10979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10981 if (!SWIG_IsOK(res1)) {
10982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10983 }
10984 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10985 {
10986 arg2 = wxString_in_helper(obj1);
10987 if (arg2 == NULL) SWIG_fail;
10988 temp2 = true;
10989 }
10990 {
10991 PyThreadState* __tstate = wxPyBeginAllowThreads();
10992 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10993 wxPyEndAllowThreads(__tstate);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 {
10997 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10998 }
10999 {
11000 if (temp2)
11001 delete arg2;
11002 }
11003 return resultobj;
11004 fail:
11005 {
11006 if (temp2)
11007 delete arg2;
11008 }
11009 return NULL;
11010 }
11011
11012
11013 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11014 PyObject *resultobj = 0;
11015 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11016 wxString *arg2 = 0 ;
11017 int arg3 = (int) 0 ;
11018 wxString result;
11019 void *argp1 = 0 ;
11020 int res1 = 0 ;
11021 bool temp2 = false ;
11022 int val3 ;
11023 int ecode3 = 0 ;
11024 PyObject * obj0 = 0 ;
11025 PyObject * obj1 = 0 ;
11026 PyObject * obj2 = 0 ;
11027 char * kwnames[] = {
11028 (char *) "self",(char *) "spec",(char *) "flags", NULL
11029 };
11030
11031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11033 if (!SWIG_IsOK(res1)) {
11034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11035 }
11036 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11037 {
11038 arg2 = wxString_in_helper(obj1);
11039 if (arg2 == NULL) SWIG_fail;
11040 temp2 = true;
11041 }
11042 if (obj2) {
11043 ecode3 = SWIG_AsVal_int(obj2, &val3);
11044 if (!SWIG_IsOK(ecode3)) {
11045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11046 }
11047 arg3 = static_cast< int >(val3);
11048 }
11049 {
11050 PyThreadState* __tstate = wxPyBeginAllowThreads();
11051 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11052 wxPyEndAllowThreads(__tstate);
11053 if (PyErr_Occurred()) SWIG_fail;
11054 }
11055 {
11056 #if wxUSE_UNICODE
11057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11058 #else
11059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11060 #endif
11061 }
11062 {
11063 if (temp2)
11064 delete arg2;
11065 }
11066 return resultobj;
11067 fail:
11068 {
11069 if (temp2)
11070 delete arg2;
11071 }
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11077 PyObject *resultobj = 0;
11078 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11079 wxString result;
11080 void *argp1 = 0 ;
11081 int res1 = 0 ;
11082 PyObject *swig_obj[1] ;
11083
11084 if (!args) SWIG_fail;
11085 swig_obj[0] = args;
11086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11087 if (!SWIG_IsOK(res1)) {
11088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11089 }
11090 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11091 {
11092 PyThreadState* __tstate = wxPyBeginAllowThreads();
11093 result = (arg1)->FindNext();
11094 wxPyEndAllowThreads(__tstate);
11095 if (PyErr_Occurred()) SWIG_fail;
11096 }
11097 {
11098 #if wxUSE_UNICODE
11099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11100 #else
11101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11102 #endif
11103 }
11104 return resultobj;
11105 fail:
11106 return NULL;
11107 }
11108
11109
11110 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj = 0;
11112 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11113 int res1 = 0 ;
11114 PyObject * obj0 = 0 ;
11115 char * kwnames[] = {
11116 (char *) "handler", NULL
11117 };
11118
11119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11120 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11121 if (!SWIG_IsOK(res1)) {
11122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11123 }
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 wxFileSystem::AddHandler(arg1);
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 resultobj = SWIG_Py_Void();
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj = 0;
11139 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11140 wxFileSystemHandler *result = 0 ;
11141 void *argp1 = 0 ;
11142 int res1 = 0 ;
11143 PyObject * obj0 = 0 ;
11144 char * kwnames[] = {
11145 (char *) "handler", NULL
11146 };
11147
11148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11150 if (!SWIG_IsOK(res1)) {
11151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11152 }
11153 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11154 {
11155 PyThreadState* __tstate = wxPyBeginAllowThreads();
11156 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11157 wxPyEndAllowThreads(__tstate);
11158 if (PyErr_Occurred()) SWIG_fail;
11159 }
11160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11161 return resultobj;
11162 fail:
11163 return NULL;
11164 }
11165
11166
11167 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11168 PyObject *resultobj = 0;
11169
11170 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 wxFileSystem::CleanUpHandlers();
11174 wxPyEndAllowThreads(__tstate);
11175 if (PyErr_Occurred()) SWIG_fail;
11176 }
11177 resultobj = SWIG_Py_Void();
11178 return resultobj;
11179 fail:
11180 return NULL;
11181 }
11182
11183
11184 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11185 PyObject *resultobj = 0;
11186 wxString *arg1 = 0 ;
11187 wxString result;
11188 bool temp1 = false ;
11189 PyObject * obj0 = 0 ;
11190 char * kwnames[] = {
11191 (char *) "filename", NULL
11192 };
11193
11194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11195 {
11196 arg1 = wxString_in_helper(obj0);
11197 if (arg1 == NULL) SWIG_fail;
11198 temp1 = true;
11199 }
11200 {
11201 PyThreadState* __tstate = wxPyBeginAllowThreads();
11202 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 {
11207 #if wxUSE_UNICODE
11208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11209 #else
11210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11211 #endif
11212 }
11213 {
11214 if (temp1)
11215 delete arg1;
11216 }
11217 return resultobj;
11218 fail:
11219 {
11220 if (temp1)
11221 delete arg1;
11222 }
11223 return NULL;
11224 }
11225
11226
11227 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11228 PyObject *resultobj = 0;
11229 wxString *arg1 = 0 ;
11230 wxString result;
11231 bool temp1 = false ;
11232 PyObject * obj0 = 0 ;
11233 char * kwnames[] = {
11234 (char *) "url", NULL
11235 };
11236
11237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11238 {
11239 arg1 = wxString_in_helper(obj0);
11240 if (arg1 == NULL) SWIG_fail;
11241 temp1 = true;
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 #if wxUSE_UNICODE
11251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11252 #else
11253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11254 #endif
11255 }
11256 {
11257 if (temp1)
11258 delete arg1;
11259 }
11260 return resultobj;
11261 fail:
11262 {
11263 if (temp1)
11264 delete arg1;
11265 }
11266 return NULL;
11267 }
11268
11269
11270 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11271 PyObject *obj;
11272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11273 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11274 return SWIG_Py_Void();
11275 }
11276
11277 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11278 return SWIG_Python_InitShadowInstance(args);
11279 }
11280
11281 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11282 PyObject *resultobj = 0;
11283 wxInternetFSHandler *result = 0 ;
11284
11285 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11289 wxPyEndAllowThreads(__tstate);
11290 if (PyErr_Occurred()) SWIG_fail;
11291 }
11292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11293 return resultobj;
11294 fail:
11295 return NULL;
11296 }
11297
11298
11299 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11300 PyObject *resultobj = 0;
11301 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11302 wxString *arg2 = 0 ;
11303 bool result;
11304 void *argp1 = 0 ;
11305 int res1 = 0 ;
11306 bool temp2 = false ;
11307 PyObject * obj0 = 0 ;
11308 PyObject * obj1 = 0 ;
11309 char * kwnames[] = {
11310 (char *) "self",(char *) "location", NULL
11311 };
11312
11313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11315 if (!SWIG_IsOK(res1)) {
11316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11317 }
11318 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11319 {
11320 arg2 = wxString_in_helper(obj1);
11321 if (arg2 == NULL) SWIG_fail;
11322 temp2 = true;
11323 }
11324 {
11325 PyThreadState* __tstate = wxPyBeginAllowThreads();
11326 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11327 wxPyEndAllowThreads(__tstate);
11328 if (PyErr_Occurred()) SWIG_fail;
11329 }
11330 {
11331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11332 }
11333 {
11334 if (temp2)
11335 delete arg2;
11336 }
11337 return resultobj;
11338 fail:
11339 {
11340 if (temp2)
11341 delete arg2;
11342 }
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11348 PyObject *resultobj = 0;
11349 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11350 wxFileSystem *arg2 = 0 ;
11351 wxString *arg3 = 0 ;
11352 wxFSFile *result = 0 ;
11353 void *argp1 = 0 ;
11354 int res1 = 0 ;
11355 void *argp2 = 0 ;
11356 int res2 = 0 ;
11357 bool temp3 = false ;
11358 PyObject * obj0 = 0 ;
11359 PyObject * obj1 = 0 ;
11360 PyObject * obj2 = 0 ;
11361 char * kwnames[] = {
11362 (char *) "self",(char *) "fs",(char *) "location", NULL
11363 };
11364
11365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11367 if (!SWIG_IsOK(res1)) {
11368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11369 }
11370 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11372 if (!SWIG_IsOK(res2)) {
11373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11374 }
11375 if (!argp2) {
11376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11377 }
11378 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11379 {
11380 arg3 = wxString_in_helper(obj2);
11381 if (arg3 == NULL) SWIG_fail;
11382 temp3 = true;
11383 }
11384 {
11385 PyThreadState* __tstate = wxPyBeginAllowThreads();
11386 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11387 wxPyEndAllowThreads(__tstate);
11388 if (PyErr_Occurred()) SWIG_fail;
11389 }
11390 {
11391 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11392 }
11393 {
11394 if (temp3)
11395 delete arg3;
11396 }
11397 return resultobj;
11398 fail:
11399 {
11400 if (temp3)
11401 delete arg3;
11402 }
11403 return NULL;
11404 }
11405
11406
11407 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11408 PyObject *obj;
11409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11410 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11411 return SWIG_Py_Void();
11412 }
11413
11414 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11415 return SWIG_Python_InitShadowInstance(args);
11416 }
11417
11418 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11419 PyObject *resultobj = 0;
11420 wxZipFSHandler *result = 0 ;
11421
11422 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 result = (wxZipFSHandler *)new wxZipFSHandler();
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11437 PyObject *resultobj = 0;
11438 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11439 wxString *arg2 = 0 ;
11440 bool result;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 bool temp2 = false ;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 char * kwnames[] = {
11447 (char *) "self",(char *) "location", NULL
11448 };
11449
11450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11452 if (!SWIG_IsOK(res1)) {
11453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11454 }
11455 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11456 {
11457 arg2 = wxString_in_helper(obj1);
11458 if (arg2 == NULL) SWIG_fail;
11459 temp2 = true;
11460 }
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11464 wxPyEndAllowThreads(__tstate);
11465 if (PyErr_Occurred()) SWIG_fail;
11466 }
11467 {
11468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11469 }
11470 {
11471 if (temp2)
11472 delete arg2;
11473 }
11474 return resultobj;
11475 fail:
11476 {
11477 if (temp2)
11478 delete arg2;
11479 }
11480 return NULL;
11481 }
11482
11483
11484 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11485 PyObject *resultobj = 0;
11486 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11487 wxFileSystem *arg2 = 0 ;
11488 wxString *arg3 = 0 ;
11489 wxFSFile *result = 0 ;
11490 void *argp1 = 0 ;
11491 int res1 = 0 ;
11492 void *argp2 = 0 ;
11493 int res2 = 0 ;
11494 bool temp3 = false ;
11495 PyObject * obj0 = 0 ;
11496 PyObject * obj1 = 0 ;
11497 PyObject * obj2 = 0 ;
11498 char * kwnames[] = {
11499 (char *) "self",(char *) "fs",(char *) "location", NULL
11500 };
11501
11502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11504 if (!SWIG_IsOK(res1)) {
11505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11506 }
11507 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11508 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11509 if (!SWIG_IsOK(res2)) {
11510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11511 }
11512 if (!argp2) {
11513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11514 }
11515 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11516 {
11517 arg3 = wxString_in_helper(obj2);
11518 if (arg3 == NULL) SWIG_fail;
11519 temp3 = true;
11520 }
11521 {
11522 PyThreadState* __tstate = wxPyBeginAllowThreads();
11523 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11524 wxPyEndAllowThreads(__tstate);
11525 if (PyErr_Occurred()) SWIG_fail;
11526 }
11527 {
11528 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11529 }
11530 {
11531 if (temp3)
11532 delete arg3;
11533 }
11534 return resultobj;
11535 fail:
11536 {
11537 if (temp3)
11538 delete arg3;
11539 }
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj = 0;
11546 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11547 wxString *arg2 = 0 ;
11548 int arg3 = (int) 0 ;
11549 wxString result;
11550 void *argp1 = 0 ;
11551 int res1 = 0 ;
11552 bool temp2 = false ;
11553 int val3 ;
11554 int ecode3 = 0 ;
11555 PyObject * obj0 = 0 ;
11556 PyObject * obj1 = 0 ;
11557 PyObject * obj2 = 0 ;
11558 char * kwnames[] = {
11559 (char *) "self",(char *) "spec",(char *) "flags", NULL
11560 };
11561
11562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11564 if (!SWIG_IsOK(res1)) {
11565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11566 }
11567 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11568 {
11569 arg2 = wxString_in_helper(obj1);
11570 if (arg2 == NULL) SWIG_fail;
11571 temp2 = true;
11572 }
11573 if (obj2) {
11574 ecode3 = SWIG_AsVal_int(obj2, &val3);
11575 if (!SWIG_IsOK(ecode3)) {
11576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11577 }
11578 arg3 = static_cast< int >(val3);
11579 }
11580 {
11581 PyThreadState* __tstate = wxPyBeginAllowThreads();
11582 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 {
11587 #if wxUSE_UNICODE
11588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11589 #else
11590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11591 #endif
11592 }
11593 {
11594 if (temp2)
11595 delete arg2;
11596 }
11597 return resultobj;
11598 fail:
11599 {
11600 if (temp2)
11601 delete arg2;
11602 }
11603 return NULL;
11604 }
11605
11606
11607 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11608 PyObject *resultobj = 0;
11609 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11610 wxString result;
11611 void *argp1 = 0 ;
11612 int res1 = 0 ;
11613 PyObject *swig_obj[1] ;
11614
11615 if (!args) SWIG_fail;
11616 swig_obj[0] = args;
11617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11618 if (!SWIG_IsOK(res1)) {
11619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11620 }
11621 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11622 {
11623 PyThreadState* __tstate = wxPyBeginAllowThreads();
11624 result = (arg1)->FindNext();
11625 wxPyEndAllowThreads(__tstate);
11626 if (PyErr_Occurred()) SWIG_fail;
11627 }
11628 {
11629 #if wxUSE_UNICODE
11630 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11631 #else
11632 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11633 #endif
11634 }
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11642 PyObject *obj;
11643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11644 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11645 return SWIG_Py_Void();
11646 }
11647
11648 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11649 return SWIG_Python_InitShadowInstance(args);
11650 }
11651
11652 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11653 PyObject *resultobj = 0;
11654 wxString *arg1 = 0 ;
11655 wxImage *arg2 = 0 ;
11656 long arg3 ;
11657 bool temp1 = false ;
11658 void *argp2 = 0 ;
11659 int res2 = 0 ;
11660 long val3 ;
11661 int ecode3 = 0 ;
11662 PyObject * obj0 = 0 ;
11663 PyObject * obj1 = 0 ;
11664 PyObject * obj2 = 0 ;
11665 char * kwnames[] = {
11666 (char *) "filename",(char *) "image",(char *) "type", NULL
11667 };
11668
11669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11670 {
11671 arg1 = wxString_in_helper(obj0);
11672 if (arg1 == NULL) SWIG_fail;
11673 temp1 = true;
11674 }
11675 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11676 if (!SWIG_IsOK(res2)) {
11677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11678 }
11679 if (!argp2) {
11680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11681 }
11682 arg2 = reinterpret_cast< wxImage * >(argp2);
11683 ecode3 = SWIG_AsVal_long(obj2, &val3);
11684 if (!SWIG_IsOK(ecode3)) {
11685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11686 }
11687 arg3 = static_cast< long >(val3);
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 resultobj = SWIG_Py_Void();
11695 {
11696 if (temp1)
11697 delete arg1;
11698 }
11699 return resultobj;
11700 fail:
11701 {
11702 if (temp1)
11703 delete arg1;
11704 }
11705 return NULL;
11706 }
11707
11708
11709 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11710 PyObject *resultobj = 0;
11711 wxString *arg1 = 0 ;
11712 wxBitmap *arg2 = 0 ;
11713 long arg3 ;
11714 bool temp1 = false ;
11715 void *argp2 = 0 ;
11716 int res2 = 0 ;
11717 long val3 ;
11718 int ecode3 = 0 ;
11719 PyObject * obj0 = 0 ;
11720 PyObject * obj1 = 0 ;
11721 PyObject * obj2 = 0 ;
11722 char * kwnames[] = {
11723 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11724 };
11725
11726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11727 {
11728 arg1 = wxString_in_helper(obj0);
11729 if (arg1 == NULL) SWIG_fail;
11730 temp1 = true;
11731 }
11732 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11733 if (!SWIG_IsOK(res2)) {
11734 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11735 }
11736 if (!argp2) {
11737 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11738 }
11739 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11740 ecode3 = SWIG_AsVal_long(obj2, &val3);
11741 if (!SWIG_IsOK(ecode3)) {
11742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11743 }
11744 arg3 = static_cast< long >(val3);
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11748 wxPyEndAllowThreads(__tstate);
11749 if (PyErr_Occurred()) SWIG_fail;
11750 }
11751 resultobj = SWIG_Py_Void();
11752 {
11753 if (temp1)
11754 delete arg1;
11755 }
11756 return resultobj;
11757 fail:
11758 {
11759 if (temp1)
11760 delete arg1;
11761 }
11762 return NULL;
11763 }
11764
11765
11766 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11767 PyObject *resultobj = 0;
11768 wxString *arg1 = 0 ;
11769 PyObject *arg2 = (PyObject *) 0 ;
11770 bool temp1 = false ;
11771 PyObject * obj0 = 0 ;
11772 PyObject * obj1 = 0 ;
11773 char * kwnames[] = {
11774 (char *) "filename",(char *) "data", NULL
11775 };
11776
11777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11778 {
11779 arg1 = wxString_in_helper(obj0);
11780 if (arg1 == NULL) SWIG_fail;
11781 temp1 = true;
11782 }
11783 arg2 = obj1;
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 resultobj = SWIG_Py_Void();
11791 {
11792 if (temp1)
11793 delete arg1;
11794 }
11795 return resultobj;
11796 fail:
11797 {
11798 if (temp1)
11799 delete arg1;
11800 }
11801 return NULL;
11802 }
11803
11804
11805 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11806 PyObject *resultobj = 0;
11807 wxMemoryFSHandler *result = 0 ;
11808
11809 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11810 {
11811 PyThreadState* __tstate = wxPyBeginAllowThreads();
11812 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11813 wxPyEndAllowThreads(__tstate);
11814 if (PyErr_Occurred()) SWIG_fail;
11815 }
11816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11817 return resultobj;
11818 fail:
11819 return NULL;
11820 }
11821
11822
11823 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11824 PyObject *resultobj = 0;
11825 wxString *arg1 = 0 ;
11826 bool temp1 = false ;
11827 PyObject * obj0 = 0 ;
11828 char * kwnames[] = {
11829 (char *) "filename", NULL
11830 };
11831
11832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11833 {
11834 arg1 = wxString_in_helper(obj0);
11835 if (arg1 == NULL) SWIG_fail;
11836 temp1 = true;
11837 }
11838 {
11839 PyThreadState* __tstate = wxPyBeginAllowThreads();
11840 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11841 wxPyEndAllowThreads(__tstate);
11842 if (PyErr_Occurred()) SWIG_fail;
11843 }
11844 resultobj = SWIG_Py_Void();
11845 {
11846 if (temp1)
11847 delete arg1;
11848 }
11849 return resultobj;
11850 fail:
11851 {
11852 if (temp1)
11853 delete arg1;
11854 }
11855 return NULL;
11856 }
11857
11858
11859 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj = 0;
11861 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11862 wxString *arg2 = 0 ;
11863 bool result;
11864 void *argp1 = 0 ;
11865 int res1 = 0 ;
11866 bool temp2 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 char * kwnames[] = {
11870 (char *) "self",(char *) "location", NULL
11871 };
11872
11873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11877 }
11878 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11879 {
11880 arg2 = wxString_in_helper(obj1);
11881 if (arg2 == NULL) SWIG_fail;
11882 temp2 = true;
11883 }
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 {
11891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11892 }
11893 {
11894 if (temp2)
11895 delete arg2;
11896 }
11897 return resultobj;
11898 fail:
11899 {
11900 if (temp2)
11901 delete arg2;
11902 }
11903 return NULL;
11904 }
11905
11906
11907 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11908 PyObject *resultobj = 0;
11909 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11910 wxFileSystem *arg2 = 0 ;
11911 wxString *arg3 = 0 ;
11912 wxFSFile *result = 0 ;
11913 void *argp1 = 0 ;
11914 int res1 = 0 ;
11915 void *argp2 = 0 ;
11916 int res2 = 0 ;
11917 bool temp3 = false ;
11918 PyObject * obj0 = 0 ;
11919 PyObject * obj1 = 0 ;
11920 PyObject * obj2 = 0 ;
11921 char * kwnames[] = {
11922 (char *) "self",(char *) "fs",(char *) "location", NULL
11923 };
11924
11925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11927 if (!SWIG_IsOK(res1)) {
11928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11929 }
11930 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11931 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11932 if (!SWIG_IsOK(res2)) {
11933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11934 }
11935 if (!argp2) {
11936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11937 }
11938 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11939 {
11940 arg3 = wxString_in_helper(obj2);
11941 if (arg3 == NULL) SWIG_fail;
11942 temp3 = true;
11943 }
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11947 wxPyEndAllowThreads(__tstate);
11948 if (PyErr_Occurred()) SWIG_fail;
11949 }
11950 {
11951 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11952 }
11953 {
11954 if (temp3)
11955 delete arg3;
11956 }
11957 return resultobj;
11958 fail:
11959 {
11960 if (temp3)
11961 delete arg3;
11962 }
11963 return NULL;
11964 }
11965
11966
11967 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11968 PyObject *resultobj = 0;
11969 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11970 wxString *arg2 = 0 ;
11971 int arg3 = (int) 0 ;
11972 wxString result;
11973 void *argp1 = 0 ;
11974 int res1 = 0 ;
11975 bool temp2 = false ;
11976 int val3 ;
11977 int ecode3 = 0 ;
11978 PyObject * obj0 = 0 ;
11979 PyObject * obj1 = 0 ;
11980 PyObject * obj2 = 0 ;
11981 char * kwnames[] = {
11982 (char *) "self",(char *) "spec",(char *) "flags", NULL
11983 };
11984
11985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11989 }
11990 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11991 {
11992 arg2 = wxString_in_helper(obj1);
11993 if (arg2 == NULL) SWIG_fail;
11994 temp2 = true;
11995 }
11996 if (obj2) {
11997 ecode3 = SWIG_AsVal_int(obj2, &val3);
11998 if (!SWIG_IsOK(ecode3)) {
11999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12000 }
12001 arg3 = static_cast< int >(val3);
12002 }
12003 {
12004 PyThreadState* __tstate = wxPyBeginAllowThreads();
12005 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12006 wxPyEndAllowThreads(__tstate);
12007 if (PyErr_Occurred()) SWIG_fail;
12008 }
12009 {
12010 #if wxUSE_UNICODE
12011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12012 #else
12013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12014 #endif
12015 }
12016 {
12017 if (temp2)
12018 delete arg2;
12019 }
12020 return resultobj;
12021 fail:
12022 {
12023 if (temp2)
12024 delete arg2;
12025 }
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12031 PyObject *resultobj = 0;
12032 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12033 wxString result;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 PyObject *swig_obj[1] ;
12037
12038 if (!args) SWIG_fail;
12039 swig_obj[0] = args;
12040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12041 if (!SWIG_IsOK(res1)) {
12042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12043 }
12044 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (arg1)->FindNext();
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 {
12052 #if wxUSE_UNICODE
12053 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12054 #else
12055 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12056 #endif
12057 }
12058 return resultobj;
12059 fail:
12060 return NULL;
12061 }
12062
12063
12064 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12065 PyObject *obj;
12066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12067 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12068 return SWIG_Py_Void();
12069 }
12070
12071 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12072 return SWIG_Python_InitShadowInstance(args);
12073 }
12074
12075 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12076 PyObject *resultobj = 0;
12077 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12078 wxString result;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 PyObject *swig_obj[1] ;
12082
12083 if (!args) SWIG_fail;
12084 swig_obj[0] = args;
12085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12086 if (!SWIG_IsOK(res1)) {
12087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12088 }
12089 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12090 {
12091 PyThreadState* __tstate = wxPyBeginAllowThreads();
12092 result = (arg1)->GetName();
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 {
12097 #if wxUSE_UNICODE
12098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12099 #else
12100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12101 #endif
12102 }
12103 return resultobj;
12104 fail:
12105 return NULL;
12106 }
12107
12108
12109 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12110 PyObject *resultobj = 0;
12111 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12112 wxString result;
12113 void *argp1 = 0 ;
12114 int res1 = 0 ;
12115 PyObject *swig_obj[1] ;
12116
12117 if (!args) SWIG_fail;
12118 swig_obj[0] = args;
12119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12120 if (!SWIG_IsOK(res1)) {
12121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12122 }
12123 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 result = (arg1)->GetExtension();
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 {
12131 #if wxUSE_UNICODE
12132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12133 #else
12134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12135 #endif
12136 }
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *resultobj = 0;
12145 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12146 long result;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12156 }
12157 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (long)(arg1)->GetType();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_From_long(static_cast< long >(result));
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12172 PyObject *resultobj = 0;
12173 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12174 wxString result;
12175 void *argp1 = 0 ;
12176 int res1 = 0 ;
12177 PyObject *swig_obj[1] ;
12178
12179 if (!args) SWIG_fail;
12180 swig_obj[0] = args;
12181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12182 if (!SWIG_IsOK(res1)) {
12183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12184 }
12185 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12186 {
12187 PyThreadState* __tstate = wxPyBeginAllowThreads();
12188 result = (arg1)->GetMimeType();
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 {
12193 #if wxUSE_UNICODE
12194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12195 #else
12196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12197 #endif
12198 }
12199 return resultobj;
12200 fail:
12201 return NULL;
12202 }
12203
12204
12205 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12206 PyObject *resultobj = 0;
12207 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12208 wxString *arg2 = 0 ;
12209 bool result;
12210 void *argp1 = 0 ;
12211 int res1 = 0 ;
12212 bool temp2 = false ;
12213 PyObject * obj0 = 0 ;
12214 PyObject * obj1 = 0 ;
12215 char * kwnames[] = {
12216 (char *) "self",(char *) "name", NULL
12217 };
12218
12219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12221 if (!SWIG_IsOK(res1)) {
12222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12223 }
12224 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12225 {
12226 arg2 = wxString_in_helper(obj1);
12227 if (arg2 == NULL) SWIG_fail;
12228 temp2 = true;
12229 }
12230 {
12231 PyThreadState* __tstate = wxPyBeginAllowThreads();
12232 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12238 }
12239 {
12240 if (temp2)
12241 delete arg2;
12242 }
12243 return resultobj;
12244 fail:
12245 {
12246 if (temp2)
12247 delete arg2;
12248 }
12249 return NULL;
12250 }
12251
12252
12253 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12254 PyObject *resultobj = 0;
12255 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12256 wxInputStream *arg2 = 0 ;
12257 bool result;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 wxPyInputStream *temp2 ;
12261 bool created2 ;
12262 PyObject * obj0 = 0 ;
12263 PyObject * obj1 = 0 ;
12264 char * kwnames[] = {
12265 (char *) "self",(char *) "stream", NULL
12266 };
12267
12268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12270 if (!SWIG_IsOK(res1)) {
12271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12272 }
12273 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12274 {
12275 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12276 arg2 = temp2->m_wxis;
12277 created2 = false;
12278 } else {
12279 PyErr_Clear(); // clear the failure of the wxPyConvert above
12280 arg2 = wxPyCBInputStream_create(obj1, false);
12281 if (arg2 == NULL) {
12282 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12283 SWIG_fail;
12284 }
12285 created2 = true;
12286 }
12287 }
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 result = (bool)(arg1)->CanRead(*arg2);
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 {
12295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12296 }
12297 {
12298 if (created2) delete arg2;
12299 }
12300 return resultobj;
12301 fail:
12302 {
12303 if (created2) delete arg2;
12304 }
12305 return NULL;
12306 }
12307
12308
12309 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj = 0;
12311 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12312 wxString *arg2 = 0 ;
12313 void *argp1 = 0 ;
12314 int res1 = 0 ;
12315 bool temp2 = false ;
12316 PyObject * obj0 = 0 ;
12317 PyObject * obj1 = 0 ;
12318 char * kwnames[] = {
12319 (char *) "self",(char *) "name", NULL
12320 };
12321
12322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12324 if (!SWIG_IsOK(res1)) {
12325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12326 }
12327 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12328 {
12329 arg2 = wxString_in_helper(obj1);
12330 if (arg2 == NULL) SWIG_fail;
12331 temp2 = true;
12332 }
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 (arg1)->SetName((wxString const &)*arg2);
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_Py_Void();
12340 {
12341 if (temp2)
12342 delete arg2;
12343 }
12344 return resultobj;
12345 fail:
12346 {
12347 if (temp2)
12348 delete arg2;
12349 }
12350 return NULL;
12351 }
12352
12353
12354 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12355 PyObject *resultobj = 0;
12356 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12357 wxString *arg2 = 0 ;
12358 void *argp1 = 0 ;
12359 int res1 = 0 ;
12360 bool temp2 = false ;
12361 PyObject * obj0 = 0 ;
12362 PyObject * obj1 = 0 ;
12363 char * kwnames[] = {
12364 (char *) "self",(char *) "extension", NULL
12365 };
12366
12367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12369 if (!SWIG_IsOK(res1)) {
12370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12371 }
12372 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12373 {
12374 arg2 = wxString_in_helper(obj1);
12375 if (arg2 == NULL) SWIG_fail;
12376 temp2 = true;
12377 }
12378 {
12379 PyThreadState* __tstate = wxPyBeginAllowThreads();
12380 (arg1)->SetExtension((wxString const &)*arg2);
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 resultobj = SWIG_Py_Void();
12385 {
12386 if (temp2)
12387 delete arg2;
12388 }
12389 return resultobj;
12390 fail:
12391 {
12392 if (temp2)
12393 delete arg2;
12394 }
12395 return NULL;
12396 }
12397
12398
12399 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12400 PyObject *resultobj = 0;
12401 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12402 long arg2 ;
12403 void *argp1 = 0 ;
12404 int res1 = 0 ;
12405 long val2 ;
12406 int ecode2 = 0 ;
12407 PyObject * obj0 = 0 ;
12408 PyObject * obj1 = 0 ;
12409 char * kwnames[] = {
12410 (char *) "self",(char *) "type", NULL
12411 };
12412
12413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12415 if (!SWIG_IsOK(res1)) {
12416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12417 }
12418 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12419 ecode2 = SWIG_AsVal_long(obj1, &val2);
12420 if (!SWIG_IsOK(ecode2)) {
12421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12422 }
12423 arg2 = static_cast< long >(val2);
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 (arg1)->SetType(arg2);
12427 wxPyEndAllowThreads(__tstate);
12428 if (PyErr_Occurred()) SWIG_fail;
12429 }
12430 resultobj = SWIG_Py_Void();
12431 return resultobj;
12432 fail:
12433 return NULL;
12434 }
12435
12436
12437 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12438 PyObject *resultobj = 0;
12439 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12440 wxString *arg2 = 0 ;
12441 void *argp1 = 0 ;
12442 int res1 = 0 ;
12443 bool temp2 = false ;
12444 PyObject * obj0 = 0 ;
12445 PyObject * obj1 = 0 ;
12446 char * kwnames[] = {
12447 (char *) "self",(char *) "mimetype", NULL
12448 };
12449
12450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12452 if (!SWIG_IsOK(res1)) {
12453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12454 }
12455 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12456 {
12457 arg2 = wxString_in_helper(obj1);
12458 if (arg2 == NULL) SWIG_fail;
12459 temp2 = true;
12460 }
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 (arg1)->SetMimeType((wxString const &)*arg2);
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = SWIG_Py_Void();
12468 {
12469 if (temp2)
12470 delete arg2;
12471 }
12472 return resultobj;
12473 fail:
12474 {
12475 if (temp2)
12476 delete arg2;
12477 }
12478 return NULL;
12479 }
12480
12481
12482 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12483 PyObject *obj;
12484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12485 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12486 return SWIG_Py_Void();
12487 }
12488
12489 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12490 PyObject *resultobj = 0;
12491 wxPyImageHandler *result = 0 ;
12492
12493 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (wxPyImageHandler *)new wxPyImageHandler();
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj = 0;
12509 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12510 PyObject *arg2 = (PyObject *) 0 ;
12511 void *argp1 = 0 ;
12512 int res1 = 0 ;
12513 PyObject * obj0 = 0 ;
12514 PyObject * obj1 = 0 ;
12515 char * kwnames[] = {
12516 (char *) "self",(char *) "self", NULL
12517 };
12518
12519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12521 if (!SWIG_IsOK(res1)) {
12522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12523 }
12524 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12525 arg2 = obj1;
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 (arg1)->_SetSelf(arg2);
12529 wxPyEndAllowThreads(__tstate);
12530 if (PyErr_Occurred()) SWIG_fail;
12531 }
12532 resultobj = SWIG_Py_Void();
12533 return resultobj;
12534 fail:
12535 return NULL;
12536 }
12537
12538
12539 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12540 PyObject *obj;
12541 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12542 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12543 return SWIG_Py_Void();
12544 }
12545
12546 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12547 return SWIG_Python_InitShadowInstance(args);
12548 }
12549
12550 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12551 PyObject *resultobj = 0;
12552 wxImageHistogram *result = 0 ;
12553
12554 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12555 {
12556 PyThreadState* __tstate = wxPyBeginAllowThreads();
12557 result = (wxImageHistogram *)new wxImageHistogram();
12558 wxPyEndAllowThreads(__tstate);
12559 if (PyErr_Occurred()) SWIG_fail;
12560 }
12561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12562 return resultobj;
12563 fail:
12564 return NULL;
12565 }
12566
12567
12568 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12569 PyObject *resultobj = 0;
12570 byte arg1 ;
12571 byte arg2 ;
12572 byte arg3 ;
12573 unsigned long result;
12574 unsigned char val1 ;
12575 int ecode1 = 0 ;
12576 unsigned char val2 ;
12577 int ecode2 = 0 ;
12578 unsigned char val3 ;
12579 int ecode3 = 0 ;
12580 PyObject * obj0 = 0 ;
12581 PyObject * obj1 = 0 ;
12582 PyObject * obj2 = 0 ;
12583 char * kwnames[] = {
12584 (char *) "r",(char *) "g",(char *) "b", NULL
12585 };
12586
12587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12588 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12589 if (!SWIG_IsOK(ecode1)) {
12590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12591 }
12592 arg1 = static_cast< byte >(val1);
12593 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12594 if (!SWIG_IsOK(ecode2)) {
12595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12596 }
12597 arg2 = static_cast< byte >(val2);
12598 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12599 if (!SWIG_IsOK(ecode3)) {
12600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12601 }
12602 arg3 = static_cast< byte >(val3);
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12606 wxPyEndAllowThreads(__tstate);
12607 if (PyErr_Occurred()) SWIG_fail;
12608 }
12609 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12617 PyObject *resultobj = 0;
12618 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12619 byte *arg2 = (byte *) 0 ;
12620 byte *arg3 = (byte *) 0 ;
12621 byte *arg4 = (byte *) 0 ;
12622 byte arg5 = (byte) 1 ;
12623 byte arg6 = (byte) 0 ;
12624 byte arg7 = (byte) 0 ;
12625 bool result;
12626 void *argp1 = 0 ;
12627 int res1 = 0 ;
12628 byte temp2 ;
12629 int res2 = SWIG_TMPOBJ ;
12630 byte temp3 ;
12631 int res3 = SWIG_TMPOBJ ;
12632 byte temp4 ;
12633 int res4 = SWIG_TMPOBJ ;
12634 unsigned char val5 ;
12635 int ecode5 = 0 ;
12636 unsigned char val6 ;
12637 int ecode6 = 0 ;
12638 unsigned char val7 ;
12639 int ecode7 = 0 ;
12640 PyObject * obj0 = 0 ;
12641 PyObject * obj1 = 0 ;
12642 PyObject * obj2 = 0 ;
12643 PyObject * obj3 = 0 ;
12644 char * kwnames[] = {
12645 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12646 };
12647
12648 arg2 = &temp2;
12649 arg3 = &temp3;
12650 arg4 = &temp4;
12651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12653 if (!SWIG_IsOK(res1)) {
12654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12655 }
12656 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12657 if (obj1) {
12658 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12659 if (!SWIG_IsOK(ecode5)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12661 }
12662 arg5 = static_cast< byte >(val5);
12663 }
12664 if (obj2) {
12665 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12666 if (!SWIG_IsOK(ecode6)) {
12667 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12668 }
12669 arg6 = static_cast< byte >(val6);
12670 }
12671 if (obj3) {
12672 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12673 if (!SWIG_IsOK(ecode7)) {
12674 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12675 }
12676 arg7 = static_cast< byte >(val7);
12677 }
12678 {
12679 PyThreadState* __tstate = wxPyBeginAllowThreads();
12680 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 {
12685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12686 }
12687 if (SWIG_IsTmpObj(res2)) {
12688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12689 } else {
12690 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12692 }
12693 if (SWIG_IsTmpObj(res3)) {
12694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12695 } else {
12696 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12698 }
12699 if (SWIG_IsTmpObj(res4)) {
12700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12701 } else {
12702 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12704 }
12705 return resultobj;
12706 fail:
12707 return NULL;
12708 }
12709
12710
12711 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12712 PyObject *resultobj = 0;
12713 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12714 unsigned long arg2 ;
12715 unsigned long result;
12716 void *argp1 = 0 ;
12717 int res1 = 0 ;
12718 unsigned long val2 ;
12719 int ecode2 = 0 ;
12720 PyObject * obj0 = 0 ;
12721 PyObject * obj1 = 0 ;
12722 char * kwnames[] = {
12723 (char *) "self",(char *) "key", NULL
12724 };
12725
12726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12728 if (!SWIG_IsOK(res1)) {
12729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12730 }
12731 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12732 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12733 if (!SWIG_IsOK(ecode2)) {
12734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12735 }
12736 arg2 = static_cast< unsigned long >(val2);
12737 {
12738 PyThreadState* __tstate = wxPyBeginAllowThreads();
12739 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12751 PyObject *resultobj = 0;
12752 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12753 byte arg2 ;
12754 byte arg3 ;
12755 byte arg4 ;
12756 unsigned long result;
12757 void *argp1 = 0 ;
12758 int res1 = 0 ;
12759 unsigned char val2 ;
12760 int ecode2 = 0 ;
12761 unsigned char val3 ;
12762 int ecode3 = 0 ;
12763 unsigned char val4 ;
12764 int ecode4 = 0 ;
12765 PyObject * obj0 = 0 ;
12766 PyObject * obj1 = 0 ;
12767 PyObject * obj2 = 0 ;
12768 PyObject * obj3 = 0 ;
12769 char * kwnames[] = {
12770 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12771 };
12772
12773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12777 }
12778 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12779 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12780 if (!SWIG_IsOK(ecode2)) {
12781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12782 }
12783 arg2 = static_cast< byte >(val2);
12784 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12785 if (!SWIG_IsOK(ecode3)) {
12786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12787 }
12788 arg3 = static_cast< byte >(val3);
12789 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12790 if (!SWIG_IsOK(ecode4)) {
12791 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12792 }
12793 arg4 = static_cast< byte >(val4);
12794 {
12795 PyThreadState* __tstate = wxPyBeginAllowThreads();
12796 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12801 return resultobj;
12802 fail:
12803 return NULL;
12804 }
12805
12806
12807 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12808 PyObject *resultobj = 0;
12809 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12810 wxColour *arg2 = 0 ;
12811 unsigned long result;
12812 void *argp1 = 0 ;
12813 int res1 = 0 ;
12814 wxColour temp2 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 char * kwnames[] = {
12818 (char *) "self",(char *) "colour", NULL
12819 };
12820
12821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12823 if (!SWIG_IsOK(res1)) {
12824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12825 }
12826 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12827 {
12828 arg2 = &temp2;
12829 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12830 }
12831 {
12832 PyThreadState* __tstate = wxPyBeginAllowThreads();
12833 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12834 wxPyEndAllowThreads(__tstate);
12835 if (PyErr_Occurred()) SWIG_fail;
12836 }
12837 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *obj;
12846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12847 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12848 return SWIG_Py_Void();
12849 }
12850
12851 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12852 return SWIG_Python_InitShadowInstance(args);
12853 }
12854
12855 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12856 PyObject *resultobj = 0;
12857 byte arg1 = (byte) 0 ;
12858 byte arg2 = (byte) 0 ;
12859 byte arg3 = (byte) 0 ;
12860 wxImage_RGBValue *result = 0 ;
12861 unsigned char val1 ;
12862 int ecode1 = 0 ;
12863 unsigned char val2 ;
12864 int ecode2 = 0 ;
12865 unsigned char val3 ;
12866 int ecode3 = 0 ;
12867 PyObject * obj0 = 0 ;
12868 PyObject * obj1 = 0 ;
12869 PyObject * obj2 = 0 ;
12870 char * kwnames[] = {
12871 (char *) "r",(char *) "g",(char *) "b", NULL
12872 };
12873
12874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12875 if (obj0) {
12876 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12877 if (!SWIG_IsOK(ecode1)) {
12878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12879 }
12880 arg1 = static_cast< byte >(val1);
12881 }
12882 if (obj1) {
12883 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12884 if (!SWIG_IsOK(ecode2)) {
12885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12886 }
12887 arg2 = static_cast< byte >(val2);
12888 }
12889 if (obj2) {
12890 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12891 if (!SWIG_IsOK(ecode3)) {
12892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12893 }
12894 arg3 = static_cast< byte >(val3);
12895 }
12896 {
12897 PyThreadState* __tstate = wxPyBeginAllowThreads();
12898 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12899 wxPyEndAllowThreads(__tstate);
12900 if (PyErr_Occurred()) SWIG_fail;
12901 }
12902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12910 PyObject *resultobj = 0;
12911 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12912 byte arg2 ;
12913 void *argp1 = 0 ;
12914 int res1 = 0 ;
12915 unsigned char val2 ;
12916 int ecode2 = 0 ;
12917 PyObject *swig_obj[2] ;
12918
12919 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12921 if (!SWIG_IsOK(res1)) {
12922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12923 }
12924 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12925 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12926 if (!SWIG_IsOK(ecode2)) {
12927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12928 }
12929 arg2 = static_cast< byte >(val2);
12930 if (arg1) (arg1)->red = arg2;
12931
12932 resultobj = SWIG_Py_Void();
12933 return resultobj;
12934 fail:
12935 return NULL;
12936 }
12937
12938
12939 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12940 PyObject *resultobj = 0;
12941 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12942 byte result;
12943 void *argp1 = 0 ;
12944 int res1 = 0 ;
12945 PyObject *swig_obj[1] ;
12946
12947 if (!args) SWIG_fail;
12948 swig_obj[0] = args;
12949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12950 if (!SWIG_IsOK(res1)) {
12951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12952 }
12953 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12954 result = (byte) ((arg1)->red);
12955 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12956 return resultobj;
12957 fail:
12958 return NULL;
12959 }
12960
12961
12962 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 PyObject *resultobj = 0;
12964 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12965 byte arg2 ;
12966 void *argp1 = 0 ;
12967 int res1 = 0 ;
12968 unsigned char val2 ;
12969 int ecode2 = 0 ;
12970 PyObject *swig_obj[2] ;
12971
12972 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12974 if (!SWIG_IsOK(res1)) {
12975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12976 }
12977 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12978 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12979 if (!SWIG_IsOK(ecode2)) {
12980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12981 }
12982 arg2 = static_cast< byte >(val2);
12983 if (arg1) (arg1)->green = arg2;
12984
12985 resultobj = SWIG_Py_Void();
12986 return resultobj;
12987 fail:
12988 return NULL;
12989 }
12990
12991
12992 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 PyObject *resultobj = 0;
12994 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12995 byte result;
12996 void *argp1 = 0 ;
12997 int res1 = 0 ;
12998 PyObject *swig_obj[1] ;
12999
13000 if (!args) SWIG_fail;
13001 swig_obj[0] = args;
13002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13003 if (!SWIG_IsOK(res1)) {
13004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13005 }
13006 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13007 result = (byte) ((arg1)->green);
13008 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13009 return resultobj;
13010 fail:
13011 return NULL;
13012 }
13013
13014
13015 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13016 PyObject *resultobj = 0;
13017 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13018 byte arg2 ;
13019 void *argp1 = 0 ;
13020 int res1 = 0 ;
13021 unsigned char val2 ;
13022 int ecode2 = 0 ;
13023 PyObject *swig_obj[2] ;
13024
13025 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13027 if (!SWIG_IsOK(res1)) {
13028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13029 }
13030 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13031 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13032 if (!SWIG_IsOK(ecode2)) {
13033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13034 }
13035 arg2 = static_cast< byte >(val2);
13036 if (arg1) (arg1)->blue = arg2;
13037
13038 resultobj = SWIG_Py_Void();
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13046 PyObject *resultobj = 0;
13047 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13048 byte result;
13049 void *argp1 = 0 ;
13050 int res1 = 0 ;
13051 PyObject *swig_obj[1] ;
13052
13053 if (!args) SWIG_fail;
13054 swig_obj[0] = args;
13055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13056 if (!SWIG_IsOK(res1)) {
13057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13058 }
13059 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13060 result = (byte) ((arg1)->blue);
13061 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13062 return resultobj;
13063 fail:
13064 return NULL;
13065 }
13066
13067
13068 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13069 PyObject *obj;
13070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13071 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13072 return SWIG_Py_Void();
13073 }
13074
13075 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13076 return SWIG_Python_InitShadowInstance(args);
13077 }
13078
13079 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13080 PyObject *resultobj = 0;
13081 double arg1 = (double) 0.0 ;
13082 double arg2 = (double) 0.0 ;
13083 double arg3 = (double) 0.0 ;
13084 wxImage_HSVValue *result = 0 ;
13085 double val1 ;
13086 int ecode1 = 0 ;
13087 double val2 ;
13088 int ecode2 = 0 ;
13089 double val3 ;
13090 int ecode3 = 0 ;
13091 PyObject * obj0 = 0 ;
13092 PyObject * obj1 = 0 ;
13093 PyObject * obj2 = 0 ;
13094 char * kwnames[] = {
13095 (char *) "h",(char *) "s",(char *) "v", NULL
13096 };
13097
13098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13099 if (obj0) {
13100 ecode1 = SWIG_AsVal_double(obj0, &val1);
13101 if (!SWIG_IsOK(ecode1)) {
13102 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13103 }
13104 arg1 = static_cast< double >(val1);
13105 }
13106 if (obj1) {
13107 ecode2 = SWIG_AsVal_double(obj1, &val2);
13108 if (!SWIG_IsOK(ecode2)) {
13109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13110 }
13111 arg2 = static_cast< double >(val2);
13112 }
13113 if (obj2) {
13114 ecode3 = SWIG_AsVal_double(obj2, &val3);
13115 if (!SWIG_IsOK(ecode3)) {
13116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13117 }
13118 arg3 = static_cast< double >(val3);
13119 }
13120 {
13121 PyThreadState* __tstate = wxPyBeginAllowThreads();
13122 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13127 return resultobj;
13128 fail:
13129 return NULL;
13130 }
13131
13132
13133 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13134 PyObject *resultobj = 0;
13135 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13136 double arg2 ;
13137 void *argp1 = 0 ;
13138 int res1 = 0 ;
13139 double val2 ;
13140 int ecode2 = 0 ;
13141 PyObject *swig_obj[2] ;
13142
13143 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13145 if (!SWIG_IsOK(res1)) {
13146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13147 }
13148 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13149 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13150 if (!SWIG_IsOK(ecode2)) {
13151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13152 }
13153 arg2 = static_cast< double >(val2);
13154 if (arg1) (arg1)->hue = arg2;
13155
13156 resultobj = SWIG_Py_Void();
13157 return resultobj;
13158 fail:
13159 return NULL;
13160 }
13161
13162
13163 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13164 PyObject *resultobj = 0;
13165 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13166 double result;
13167 void *argp1 = 0 ;
13168 int res1 = 0 ;
13169 PyObject *swig_obj[1] ;
13170
13171 if (!args) SWIG_fail;
13172 swig_obj[0] = args;
13173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13174 if (!SWIG_IsOK(res1)) {
13175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13176 }
13177 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13178 result = (double) ((arg1)->hue);
13179 resultobj = SWIG_From_double(static_cast< double >(result));
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13187 PyObject *resultobj = 0;
13188 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13189 double arg2 ;
13190 void *argp1 = 0 ;
13191 int res1 = 0 ;
13192 double val2 ;
13193 int ecode2 = 0 ;
13194 PyObject *swig_obj[2] ;
13195
13196 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13198 if (!SWIG_IsOK(res1)) {
13199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13200 }
13201 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13202 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13203 if (!SWIG_IsOK(ecode2)) {
13204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13205 }
13206 arg2 = static_cast< double >(val2);
13207 if (arg1) (arg1)->saturation = arg2;
13208
13209 resultobj = SWIG_Py_Void();
13210 return resultobj;
13211 fail:
13212 return NULL;
13213 }
13214
13215
13216 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13217 PyObject *resultobj = 0;
13218 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13219 double result;
13220 void *argp1 = 0 ;
13221 int res1 = 0 ;
13222 PyObject *swig_obj[1] ;
13223
13224 if (!args) SWIG_fail;
13225 swig_obj[0] = args;
13226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13227 if (!SWIG_IsOK(res1)) {
13228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13229 }
13230 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13231 result = (double) ((arg1)->saturation);
13232 resultobj = SWIG_From_double(static_cast< double >(result));
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13240 PyObject *resultobj = 0;
13241 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13242 double arg2 ;
13243 void *argp1 = 0 ;
13244 int res1 = 0 ;
13245 double val2 ;
13246 int ecode2 = 0 ;
13247 PyObject *swig_obj[2] ;
13248
13249 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13251 if (!SWIG_IsOK(res1)) {
13252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13253 }
13254 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13255 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13256 if (!SWIG_IsOK(ecode2)) {
13257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13258 }
13259 arg2 = static_cast< double >(val2);
13260 if (arg1) (arg1)->value = arg2;
13261
13262 resultobj = SWIG_Py_Void();
13263 return resultobj;
13264 fail:
13265 return NULL;
13266 }
13267
13268
13269 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13270 PyObject *resultobj = 0;
13271 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13272 double result;
13273 void *argp1 = 0 ;
13274 int res1 = 0 ;
13275 PyObject *swig_obj[1] ;
13276
13277 if (!args) SWIG_fail;
13278 swig_obj[0] = args;
13279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13280 if (!SWIG_IsOK(res1)) {
13281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13282 }
13283 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13284 result = (double) ((arg1)->value);
13285 resultobj = SWIG_From_double(static_cast< double >(result));
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13293 PyObject *obj;
13294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13295 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13296 return SWIG_Py_Void();
13297 }
13298
13299 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13300 return SWIG_Python_InitShadowInstance(args);
13301 }
13302
13303 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = 0;
13305 wxString *arg1 = 0 ;
13306 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13307 int arg3 = (int) -1 ;
13308 wxImage *result = 0 ;
13309 bool temp1 = false ;
13310 long val2 ;
13311 int ecode2 = 0 ;
13312 int val3 ;
13313 int ecode3 = 0 ;
13314 PyObject * obj0 = 0 ;
13315 PyObject * obj1 = 0 ;
13316 PyObject * obj2 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "name",(char *) "type",(char *) "index", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13322 {
13323 arg1 = wxString_in_helper(obj0);
13324 if (arg1 == NULL) SWIG_fail;
13325 temp1 = true;
13326 }
13327 if (obj1) {
13328 ecode2 = SWIG_AsVal_long(obj1, &val2);
13329 if (!SWIG_IsOK(ecode2)) {
13330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13331 }
13332 arg2 = static_cast< long >(val2);
13333 }
13334 if (obj2) {
13335 ecode3 = SWIG_AsVal_int(obj2, &val3);
13336 if (!SWIG_IsOK(ecode3)) {
13337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13338 }
13339 arg3 = static_cast< int >(val3);
13340 }
13341 {
13342 PyThreadState* __tstate = wxPyBeginAllowThreads();
13343 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13344 wxPyEndAllowThreads(__tstate);
13345 if (PyErr_Occurred()) SWIG_fail;
13346 }
13347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13348 {
13349 if (temp1)
13350 delete arg1;
13351 }
13352 return resultobj;
13353 fail:
13354 {
13355 if (temp1)
13356 delete arg1;
13357 }
13358 return NULL;
13359 }
13360
13361
13362 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13363 PyObject *resultobj = 0;
13364 wxImage *arg1 = (wxImage *) 0 ;
13365 void *argp1 = 0 ;
13366 int res1 = 0 ;
13367 PyObject *swig_obj[1] ;
13368
13369 if (!args) SWIG_fail;
13370 swig_obj[0] = args;
13371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13372 if (!SWIG_IsOK(res1)) {
13373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13374 }
13375 arg1 = reinterpret_cast< wxImage * >(argp1);
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 delete arg1;
13379
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 resultobj = SWIG_Py_Void();
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj = 0;
13392 wxString *arg1 = 0 ;
13393 wxString *arg2 = 0 ;
13394 int arg3 = (int) -1 ;
13395 wxImage *result = 0 ;
13396 bool temp1 = false ;
13397 bool temp2 = false ;
13398 int val3 ;
13399 int ecode3 = 0 ;
13400 PyObject * obj0 = 0 ;
13401 PyObject * obj1 = 0 ;
13402 PyObject * obj2 = 0 ;
13403 char * kwnames[] = {
13404 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13405 };
13406
13407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13408 {
13409 arg1 = wxString_in_helper(obj0);
13410 if (arg1 == NULL) SWIG_fail;
13411 temp1 = true;
13412 }
13413 {
13414 arg2 = wxString_in_helper(obj1);
13415 if (arg2 == NULL) SWIG_fail;
13416 temp2 = true;
13417 }
13418 if (obj2) {
13419 ecode3 = SWIG_AsVal_int(obj2, &val3);
13420 if (!SWIG_IsOK(ecode3)) {
13421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13422 }
13423 arg3 = static_cast< int >(val3);
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13432 {
13433 if (temp1)
13434 delete arg1;
13435 }
13436 {
13437 if (temp2)
13438 delete arg2;
13439 }
13440 return resultobj;
13441 fail:
13442 {
13443 if (temp1)
13444 delete arg1;
13445 }
13446 {
13447 if (temp2)
13448 delete arg2;
13449 }
13450 return NULL;
13451 }
13452
13453
13454 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13455 PyObject *resultobj = 0;
13456 wxInputStream *arg1 = 0 ;
13457 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13458 int arg3 = (int) -1 ;
13459 wxImage *result = 0 ;
13460 wxPyInputStream *temp1 ;
13461 bool created1 ;
13462 long val2 ;
13463 int ecode2 = 0 ;
13464 int val3 ;
13465 int ecode3 = 0 ;
13466 PyObject * obj0 = 0 ;
13467 PyObject * obj1 = 0 ;
13468 PyObject * obj2 = 0 ;
13469 char * kwnames[] = {
13470 (char *) "stream",(char *) "type",(char *) "index", NULL
13471 };
13472
13473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13474 {
13475 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13476 arg1 = temp1->m_wxis;
13477 created1 = false;
13478 } else {
13479 PyErr_Clear(); // clear the failure of the wxPyConvert above
13480 arg1 = wxPyCBInputStream_create(obj0, false);
13481 if (arg1 == NULL) {
13482 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13483 SWIG_fail;
13484 }
13485 created1 = true;
13486 }
13487 }
13488 if (obj1) {
13489 ecode2 = SWIG_AsVal_long(obj1, &val2);
13490 if (!SWIG_IsOK(ecode2)) {
13491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13492 }
13493 arg2 = static_cast< long >(val2);
13494 }
13495 if (obj2) {
13496 ecode3 = SWIG_AsVal_int(obj2, &val3);
13497 if (!SWIG_IsOK(ecode3)) {
13498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13499 }
13500 arg3 = static_cast< int >(val3);
13501 }
13502 {
13503 PyThreadState* __tstate = wxPyBeginAllowThreads();
13504 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13505 wxPyEndAllowThreads(__tstate);
13506 if (PyErr_Occurred()) SWIG_fail;
13507 }
13508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13509 {
13510 if (created1) delete arg1;
13511 }
13512 return resultobj;
13513 fail:
13514 {
13515 if (created1) delete arg1;
13516 }
13517 return NULL;
13518 }
13519
13520
13521 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13522 PyObject *resultobj = 0;
13523 wxInputStream *arg1 = 0 ;
13524 wxString *arg2 = 0 ;
13525 int arg3 = (int) -1 ;
13526 wxImage *result = 0 ;
13527 wxPyInputStream *temp1 ;
13528 bool created1 ;
13529 bool temp2 = false ;
13530 int val3 ;
13531 int ecode3 = 0 ;
13532 PyObject * obj0 = 0 ;
13533 PyObject * obj1 = 0 ;
13534 PyObject * obj2 = 0 ;
13535 char * kwnames[] = {
13536 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13537 };
13538
13539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13540 {
13541 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13542 arg1 = temp1->m_wxis;
13543 created1 = false;
13544 } else {
13545 PyErr_Clear(); // clear the failure of the wxPyConvert above
13546 arg1 = wxPyCBInputStream_create(obj0, false);
13547 if (arg1 == NULL) {
13548 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13549 SWIG_fail;
13550 }
13551 created1 = true;
13552 }
13553 }
13554 {
13555 arg2 = wxString_in_helper(obj1);
13556 if (arg2 == NULL) SWIG_fail;
13557 temp2 = true;
13558 }
13559 if (obj2) {
13560 ecode3 = SWIG_AsVal_int(obj2, &val3);
13561 if (!SWIG_IsOK(ecode3)) {
13562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13563 }
13564 arg3 = static_cast< int >(val3);
13565 }
13566 {
13567 PyThreadState* __tstate = wxPyBeginAllowThreads();
13568 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13573 {
13574 if (created1) delete arg1;
13575 }
13576 {
13577 if (temp2)
13578 delete arg2;
13579 }
13580 return resultobj;
13581 fail:
13582 {
13583 if (created1) delete arg1;
13584 }
13585 {
13586 if (temp2)
13587 delete arg2;
13588 }
13589 return NULL;
13590 }
13591
13592
13593 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13594 PyObject *resultobj = 0;
13595 int arg1 = (int) 0 ;
13596 int arg2 = (int) 0 ;
13597 bool arg3 = (bool) true ;
13598 wxImage *result = 0 ;
13599 int val1 ;
13600 int ecode1 = 0 ;
13601 int val2 ;
13602 int ecode2 = 0 ;
13603 bool val3 ;
13604 int ecode3 = 0 ;
13605 PyObject * obj0 = 0 ;
13606 PyObject * obj1 = 0 ;
13607 PyObject * obj2 = 0 ;
13608 char * kwnames[] = {
13609 (char *) "width",(char *) "height",(char *) "clear", NULL
13610 };
13611
13612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13613 if (obj0) {
13614 ecode1 = SWIG_AsVal_int(obj0, &val1);
13615 if (!SWIG_IsOK(ecode1)) {
13616 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13617 }
13618 arg1 = static_cast< int >(val1);
13619 }
13620 if (obj1) {
13621 ecode2 = SWIG_AsVal_int(obj1, &val2);
13622 if (!SWIG_IsOK(ecode2)) {
13623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13624 }
13625 arg2 = static_cast< int >(val2);
13626 }
13627 if (obj2) {
13628 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13629 if (!SWIG_IsOK(ecode3)) {
13630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13631 }
13632 arg3 = static_cast< bool >(val3);
13633 }
13634 {
13635 PyThreadState* __tstate = wxPyBeginAllowThreads();
13636 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj = 0;
13649 wxBitmap *arg1 = 0 ;
13650 wxImage *result = 0 ;
13651 void *argp1 = 0 ;
13652 int res1 = 0 ;
13653 PyObject * obj0 = 0 ;
13654 char * kwnames[] = {
13655 (char *) "bitmap", NULL
13656 };
13657
13658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13659 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13660 if (!SWIG_IsOK(res1)) {
13661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13662 }
13663 if (!argp1) {
13664 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13665 }
13666 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13667 {
13668 if (!wxPyCheckForApp()) SWIG_fail;
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj = 0;
13683 int arg1 ;
13684 int arg2 ;
13685 buffer arg3 ;
13686 int arg4 ;
13687 wxImage *result = 0 ;
13688 int val1 ;
13689 int ecode1 = 0 ;
13690 int val2 ;
13691 int ecode2 = 0 ;
13692 Py_ssize_t temp3 ;
13693 PyObject * obj0 = 0 ;
13694 PyObject * obj1 = 0 ;
13695 PyObject * obj2 = 0 ;
13696 char * kwnames[] = {
13697 (char *) "width",(char *) "height",(char *) "data", NULL
13698 };
13699
13700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13701 ecode1 = SWIG_AsVal_int(obj0, &val1);
13702 if (!SWIG_IsOK(ecode1)) {
13703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13704 }
13705 arg1 = static_cast< int >(val1);
13706 ecode2 = SWIG_AsVal_int(obj1, &val2);
13707 if (!SWIG_IsOK(ecode2)) {
13708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13709 }
13710 arg2 = static_cast< int >(val2);
13711 {
13712 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13713 arg4 = (int)temp3;
13714 }
13715 {
13716 PyThreadState* __tstate = wxPyBeginAllowThreads();
13717 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13722 return resultobj;
13723 fail:
13724 return NULL;
13725 }
13726
13727
13728 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj = 0;
13730 int arg1 ;
13731 int arg2 ;
13732 buffer arg3 ;
13733 int arg4 ;
13734 buffer arg5 ;
13735 int arg6 ;
13736 wxImage *result = 0 ;
13737 int val1 ;
13738 int ecode1 = 0 ;
13739 int val2 ;
13740 int ecode2 = 0 ;
13741 Py_ssize_t temp3 ;
13742 Py_ssize_t temp5 ;
13743 PyObject * obj0 = 0 ;
13744 PyObject * obj1 = 0 ;
13745 PyObject * obj2 = 0 ;
13746 PyObject * obj3 = 0 ;
13747 char * kwnames[] = {
13748 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13749 };
13750
13751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13752 ecode1 = SWIG_AsVal_int(obj0, &val1);
13753 if (!SWIG_IsOK(ecode1)) {
13754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13755 }
13756 arg1 = static_cast< int >(val1);
13757 ecode2 = SWIG_AsVal_int(obj1, &val2);
13758 if (!SWIG_IsOK(ecode2)) {
13759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13760 }
13761 arg2 = static_cast< int >(val2);
13762 {
13763 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13764 arg4 = (int)temp3;
13765 }
13766 {
13767 if (obj3 != Py_None) {
13768 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13769 arg6 = (int)temp5;
13770 }
13771 }
13772 {
13773 PyThreadState* __tstate = wxPyBeginAllowThreads();
13774 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13775 wxPyEndAllowThreads(__tstate);
13776 if (PyErr_Occurred()) SWIG_fail;
13777 }
13778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13779 return resultobj;
13780 fail:
13781 return NULL;
13782 }
13783
13784
13785 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13786 PyObject *resultobj = 0;
13787 wxImage *arg1 = (wxImage *) 0 ;
13788 int arg2 ;
13789 int arg3 ;
13790 bool arg4 = (bool) true ;
13791 void *argp1 = 0 ;
13792 int res1 = 0 ;
13793 int val2 ;
13794 int ecode2 = 0 ;
13795 int val3 ;
13796 int ecode3 = 0 ;
13797 bool val4 ;
13798 int ecode4 = 0 ;
13799 PyObject * obj0 = 0 ;
13800 PyObject * obj1 = 0 ;
13801 PyObject * obj2 = 0 ;
13802 PyObject * obj3 = 0 ;
13803 char * kwnames[] = {
13804 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13805 };
13806
13807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13809 if (!SWIG_IsOK(res1)) {
13810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13811 }
13812 arg1 = reinterpret_cast< wxImage * >(argp1);
13813 ecode2 = SWIG_AsVal_int(obj1, &val2);
13814 if (!SWIG_IsOK(ecode2)) {
13815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13816 }
13817 arg2 = static_cast< int >(val2);
13818 ecode3 = SWIG_AsVal_int(obj2, &val3);
13819 if (!SWIG_IsOK(ecode3)) {
13820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13821 }
13822 arg3 = static_cast< int >(val3);
13823 if (obj3) {
13824 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13825 if (!SWIG_IsOK(ecode4)) {
13826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13827 }
13828 arg4 = static_cast< bool >(val4);
13829 }
13830 {
13831 PyThreadState* __tstate = wxPyBeginAllowThreads();
13832 (arg1)->Create(arg2,arg3,arg4);
13833 wxPyEndAllowThreads(__tstate);
13834 if (PyErr_Occurred()) SWIG_fail;
13835 }
13836 resultobj = SWIG_Py_Void();
13837 return resultobj;
13838 fail:
13839 return NULL;
13840 }
13841
13842
13843 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13844 PyObject *resultobj = 0;
13845 wxImage *arg1 = (wxImage *) 0 ;
13846 void *argp1 = 0 ;
13847 int res1 = 0 ;
13848 PyObject *swig_obj[1] ;
13849
13850 if (!args) SWIG_fail;
13851 swig_obj[0] = args;
13852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13853 if (!SWIG_IsOK(res1)) {
13854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13855 }
13856 arg1 = reinterpret_cast< wxImage * >(argp1);
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 (arg1)->Destroy();
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 resultobj = SWIG_Py_Void();
13864 return resultobj;
13865 fail:
13866 return NULL;
13867 }
13868
13869
13870 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj = 0;
13872 wxImage *arg1 = (wxImage *) 0 ;
13873 int arg2 ;
13874 int arg3 ;
13875 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13876 SwigValueWrapper<wxImage > result;
13877 void *argp1 = 0 ;
13878 int res1 = 0 ;
13879 int val2 ;
13880 int ecode2 = 0 ;
13881 int val3 ;
13882 int ecode3 = 0 ;
13883 int val4 ;
13884 int ecode4 = 0 ;
13885 PyObject * obj0 = 0 ;
13886 PyObject * obj1 = 0 ;
13887 PyObject * obj2 = 0 ;
13888 PyObject * obj3 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13895 if (!SWIG_IsOK(res1)) {
13896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13897 }
13898 arg1 = reinterpret_cast< wxImage * >(argp1);
13899 ecode2 = SWIG_AsVal_int(obj1, &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13902 }
13903 arg2 = static_cast< int >(val2);
13904 ecode3 = SWIG_AsVal_int(obj2, &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13907 }
13908 arg3 = static_cast< int >(val3);
13909 if (obj3) {
13910 ecode4 = SWIG_AsVal_int(obj3, &val4);
13911 if (!SWIG_IsOK(ecode4)) {
13912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13913 }
13914 arg4 = static_cast< int >(val4);
13915 }
13916 {
13917 PyThreadState* __tstate = wxPyBeginAllowThreads();
13918 result = (arg1)->Scale(arg2,arg3,arg4);
13919 wxPyEndAllowThreads(__tstate);
13920 if (PyErr_Occurred()) SWIG_fail;
13921 }
13922 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13923 return resultobj;
13924 fail:
13925 return NULL;
13926 }
13927
13928
13929 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13930 PyObject *resultobj = 0;
13931 wxImage *arg1 = (wxImage *) 0 ;
13932 int arg2 ;
13933 int arg3 ;
13934 SwigValueWrapper<wxImage > result;
13935 void *argp1 = 0 ;
13936 int res1 = 0 ;
13937 int val2 ;
13938 int ecode2 = 0 ;
13939 int val3 ;
13940 int ecode3 = 0 ;
13941 PyObject * obj0 = 0 ;
13942 PyObject * obj1 = 0 ;
13943 PyObject * obj2 = 0 ;
13944 char * kwnames[] = {
13945 (char *) "self",(char *) "width",(char *) "height", NULL
13946 };
13947
13948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13950 if (!SWIG_IsOK(res1)) {
13951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13952 }
13953 arg1 = reinterpret_cast< wxImage * >(argp1);
13954 ecode2 = SWIG_AsVal_int(obj1, &val2);
13955 if (!SWIG_IsOK(ecode2)) {
13956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13957 }
13958 arg2 = static_cast< int >(val2);
13959 ecode3 = SWIG_AsVal_int(obj2, &val3);
13960 if (!SWIG_IsOK(ecode3)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13962 }
13963 arg3 = static_cast< int >(val3);
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj = 0;
13979 wxImage *arg1 = (wxImage *) 0 ;
13980 int arg2 ;
13981 int arg3 ;
13982 SwigValueWrapper<wxImage > result;
13983 void *argp1 = 0 ;
13984 int res1 = 0 ;
13985 int val2 ;
13986 int ecode2 = 0 ;
13987 int val3 ;
13988 int ecode3 = 0 ;
13989 PyObject * obj0 = 0 ;
13990 PyObject * obj1 = 0 ;
13991 PyObject * obj2 = 0 ;
13992 char * kwnames[] = {
13993 (char *) "self",(char *) "width",(char *) "height", NULL
13994 };
13995
13996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13998 if (!SWIG_IsOK(res1)) {
13999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14000 }
14001 arg1 = reinterpret_cast< wxImage * >(argp1);
14002 ecode2 = SWIG_AsVal_int(obj1, &val2);
14003 if (!SWIG_IsOK(ecode2)) {
14004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14005 }
14006 arg2 = static_cast< int >(val2);
14007 ecode3 = SWIG_AsVal_int(obj2, &val3);
14008 if (!SWIG_IsOK(ecode3)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14010 }
14011 arg3 = static_cast< int >(val3);
14012 {
14013 PyThreadState* __tstate = wxPyBeginAllowThreads();
14014 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14026 PyObject *resultobj = 0;
14027 wxImage *arg1 = (wxImage *) 0 ;
14028 int arg2 ;
14029 SwigValueWrapper<wxImage > result;
14030 void *argp1 = 0 ;
14031 int res1 = 0 ;
14032 int val2 ;
14033 int ecode2 = 0 ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 char * kwnames[] = {
14037 (char *) "self",(char *) "radius", NULL
14038 };
14039
14040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14042 if (!SWIG_IsOK(res1)) {
14043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14044 }
14045 arg1 = reinterpret_cast< wxImage * >(argp1);
14046 ecode2 = SWIG_AsVal_int(obj1, &val2);
14047 if (!SWIG_IsOK(ecode2)) {
14048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14049 }
14050 arg2 = static_cast< int >(val2);
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (arg1)->Blur(arg2);
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14058 return resultobj;
14059 fail:
14060 return NULL;
14061 }
14062
14063
14064 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14065 PyObject *resultobj = 0;
14066 wxImage *arg1 = (wxImage *) 0 ;
14067 int arg2 ;
14068 SwigValueWrapper<wxImage > result;
14069 void *argp1 = 0 ;
14070 int res1 = 0 ;
14071 int val2 ;
14072 int ecode2 = 0 ;
14073 PyObject * obj0 = 0 ;
14074 PyObject * obj1 = 0 ;
14075 char * kwnames[] = {
14076 (char *) "self",(char *) "radius", NULL
14077 };
14078
14079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14081 if (!SWIG_IsOK(res1)) {
14082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14083 }
14084 arg1 = reinterpret_cast< wxImage * >(argp1);
14085 ecode2 = SWIG_AsVal_int(obj1, &val2);
14086 if (!SWIG_IsOK(ecode2)) {
14087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14088 }
14089 arg2 = static_cast< int >(val2);
14090 {
14091 PyThreadState* __tstate = wxPyBeginAllowThreads();
14092 result = (arg1)->BlurHorizontal(arg2);
14093 wxPyEndAllowThreads(__tstate);
14094 if (PyErr_Occurred()) SWIG_fail;
14095 }
14096 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14097 return resultobj;
14098 fail:
14099 return NULL;
14100 }
14101
14102
14103 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14104 PyObject *resultobj = 0;
14105 wxImage *arg1 = (wxImage *) 0 ;
14106 int arg2 ;
14107 SwigValueWrapper<wxImage > result;
14108 void *argp1 = 0 ;
14109 int res1 = 0 ;
14110 int val2 ;
14111 int ecode2 = 0 ;
14112 PyObject * obj0 = 0 ;
14113 PyObject * obj1 = 0 ;
14114 char * kwnames[] = {
14115 (char *) "self",(char *) "radius", NULL
14116 };
14117
14118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14120 if (!SWIG_IsOK(res1)) {
14121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14122 }
14123 arg1 = reinterpret_cast< wxImage * >(argp1);
14124 ecode2 = SWIG_AsVal_int(obj1, &val2);
14125 if (!SWIG_IsOK(ecode2)) {
14126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14127 }
14128 arg2 = static_cast< int >(val2);
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (arg1)->BlurVertical(arg2);
14132 wxPyEndAllowThreads(__tstate);
14133 if (PyErr_Occurred()) SWIG_fail;
14134 }
14135 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj = 0;
14144 wxImage *arg1 = (wxImage *) 0 ;
14145 int arg2 ;
14146 int arg3 ;
14147 SwigValueWrapper<wxImage > result;
14148 void *argp1 = 0 ;
14149 int res1 = 0 ;
14150 int val2 ;
14151 int ecode2 = 0 ;
14152 int val3 ;
14153 int ecode3 = 0 ;
14154 PyObject * obj0 = 0 ;
14155 PyObject * obj1 = 0 ;
14156 PyObject * obj2 = 0 ;
14157 char * kwnames[] = {
14158 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14159 };
14160
14161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14163 if (!SWIG_IsOK(res1)) {
14164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14165 }
14166 arg1 = reinterpret_cast< wxImage * >(argp1);
14167 ecode2 = SWIG_AsVal_int(obj1, &val2);
14168 if (!SWIG_IsOK(ecode2)) {
14169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14170 }
14171 arg2 = static_cast< int >(val2);
14172 ecode3 = SWIG_AsVal_int(obj2, &val3);
14173 if (!SWIG_IsOK(ecode3)) {
14174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14175 }
14176 arg3 = static_cast< int >(val3);
14177 {
14178 PyThreadState* __tstate = wxPyBeginAllowThreads();
14179 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14184 return resultobj;
14185 fail:
14186 return NULL;
14187 }
14188
14189
14190 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14191 PyObject *resultobj = 0;
14192 wxImage *arg1 = (wxImage *) 0 ;
14193 int arg2 ;
14194 int arg3 ;
14195 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14196 wxImage *result = 0 ;
14197 void *argp1 = 0 ;
14198 int res1 = 0 ;
14199 int val2 ;
14200 int ecode2 = 0 ;
14201 int val3 ;
14202 int ecode3 = 0 ;
14203 int val4 ;
14204 int ecode4 = 0 ;
14205 PyObject * obj0 = 0 ;
14206 PyObject * obj1 = 0 ;
14207 PyObject * obj2 = 0 ;
14208 PyObject * obj3 = 0 ;
14209 char * kwnames[] = {
14210 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14211 };
14212
14213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14215 if (!SWIG_IsOK(res1)) {
14216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14217 }
14218 arg1 = reinterpret_cast< wxImage * >(argp1);
14219 ecode2 = SWIG_AsVal_int(obj1, &val2);
14220 if (!SWIG_IsOK(ecode2)) {
14221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14222 }
14223 arg2 = static_cast< int >(val2);
14224 ecode3 = SWIG_AsVal_int(obj2, &val3);
14225 if (!SWIG_IsOK(ecode3)) {
14226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14227 }
14228 arg3 = static_cast< int >(val3);
14229 if (obj3) {
14230 ecode4 = SWIG_AsVal_int(obj3, &val4);
14231 if (!SWIG_IsOK(ecode4)) {
14232 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14233 }
14234 arg4 = static_cast< int >(val4);
14235 }
14236 {
14237 PyThreadState* __tstate = wxPyBeginAllowThreads();
14238 {
14239 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14240 result = (wxImage *) &_result_ref;
14241 }
14242 wxPyEndAllowThreads(__tstate);
14243 if (PyErr_Occurred()) SWIG_fail;
14244 }
14245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14246 return resultobj;
14247 fail:
14248 return NULL;
14249 }
14250
14251
14252 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14253 PyObject *resultobj = 0;
14254 wxImage *arg1 = (wxImage *) 0 ;
14255 wxSize *arg2 = 0 ;
14256 wxPoint *arg3 = 0 ;
14257 int arg4 = (int) -1 ;
14258 int arg5 = (int) -1 ;
14259 int arg6 = (int) -1 ;
14260 wxImage *result = 0 ;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 wxSize temp2 ;
14264 wxPoint temp3 ;
14265 int val4 ;
14266 int ecode4 = 0 ;
14267 int val5 ;
14268 int ecode5 = 0 ;
14269 int val6 ;
14270 int ecode6 = 0 ;
14271 PyObject * obj0 = 0 ;
14272 PyObject * obj1 = 0 ;
14273 PyObject * obj2 = 0 ;
14274 PyObject * obj3 = 0 ;
14275 PyObject * obj4 = 0 ;
14276 PyObject * obj5 = 0 ;
14277 char * kwnames[] = {
14278 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14279 };
14280
14281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14283 if (!SWIG_IsOK(res1)) {
14284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14285 }
14286 arg1 = reinterpret_cast< wxImage * >(argp1);
14287 {
14288 arg2 = &temp2;
14289 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14290 }
14291 {
14292 arg3 = &temp3;
14293 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14294 }
14295 if (obj3) {
14296 ecode4 = SWIG_AsVal_int(obj3, &val4);
14297 if (!SWIG_IsOK(ecode4)) {
14298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14299 }
14300 arg4 = static_cast< int >(val4);
14301 }
14302 if (obj4) {
14303 ecode5 = SWIG_AsVal_int(obj4, &val5);
14304 if (!SWIG_IsOK(ecode5)) {
14305 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14306 }
14307 arg5 = static_cast< int >(val5);
14308 }
14309 if (obj5) {
14310 ecode6 = SWIG_AsVal_int(obj5, &val6);
14311 if (!SWIG_IsOK(ecode6)) {
14312 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14313 }
14314 arg6 = static_cast< int >(val6);
14315 }
14316 {
14317 PyThreadState* __tstate = wxPyBeginAllowThreads();
14318 {
14319 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14320 result = (wxImage *) &_result_ref;
14321 }
14322 wxPyEndAllowThreads(__tstate);
14323 if (PyErr_Occurred()) SWIG_fail;
14324 }
14325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14326 return resultobj;
14327 fail:
14328 return NULL;
14329 }
14330
14331
14332 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14333 PyObject *resultobj = 0;
14334 wxImage *arg1 = (wxImage *) 0 ;
14335 int arg2 ;
14336 int arg3 ;
14337 byte arg4 ;
14338 byte arg5 ;
14339 byte arg6 ;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 int val2 ;
14343 int ecode2 = 0 ;
14344 int val3 ;
14345 int ecode3 = 0 ;
14346 unsigned char val4 ;
14347 int ecode4 = 0 ;
14348 unsigned char val5 ;
14349 int ecode5 = 0 ;
14350 unsigned char val6 ;
14351 int ecode6 = 0 ;
14352 PyObject * obj0 = 0 ;
14353 PyObject * obj1 = 0 ;
14354 PyObject * obj2 = 0 ;
14355 PyObject * obj3 = 0 ;
14356 PyObject * obj4 = 0 ;
14357 PyObject * obj5 = 0 ;
14358 char * kwnames[] = {
14359 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14360 };
14361
14362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14364 if (!SWIG_IsOK(res1)) {
14365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14366 }
14367 arg1 = reinterpret_cast< wxImage * >(argp1);
14368 ecode2 = SWIG_AsVal_int(obj1, &val2);
14369 if (!SWIG_IsOK(ecode2)) {
14370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14371 }
14372 arg2 = static_cast< int >(val2);
14373 ecode3 = SWIG_AsVal_int(obj2, &val3);
14374 if (!SWIG_IsOK(ecode3)) {
14375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14376 }
14377 arg3 = static_cast< int >(val3);
14378 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14379 if (!SWIG_IsOK(ecode4)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14381 }
14382 arg4 = static_cast< byte >(val4);
14383 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14384 if (!SWIG_IsOK(ecode5)) {
14385 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14386 }
14387 arg5 = static_cast< byte >(val5);
14388 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14389 if (!SWIG_IsOK(ecode6)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14391 }
14392 arg6 = static_cast< byte >(val6);
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 resultobj = SWIG_Py_Void();
14400 return resultobj;
14401 fail:
14402 return NULL;
14403 }
14404
14405
14406 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14407 PyObject *resultobj = 0;
14408 wxImage *arg1 = (wxImage *) 0 ;
14409 wxRect *arg2 = 0 ;
14410 byte arg3 ;
14411 byte arg4 ;
14412 byte arg5 ;
14413 void *argp1 = 0 ;
14414 int res1 = 0 ;
14415 wxRect temp2 ;
14416 unsigned char val3 ;
14417 int ecode3 = 0 ;
14418 unsigned char val4 ;
14419 int ecode4 = 0 ;
14420 unsigned char val5 ;
14421 int ecode5 = 0 ;
14422 PyObject * obj0 = 0 ;
14423 PyObject * obj1 = 0 ;
14424 PyObject * obj2 = 0 ;
14425 PyObject * obj3 = 0 ;
14426 PyObject * obj4 = 0 ;
14427 char * kwnames[] = {
14428 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14429 };
14430
14431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14433 if (!SWIG_IsOK(res1)) {
14434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14435 }
14436 arg1 = reinterpret_cast< wxImage * >(argp1);
14437 {
14438 arg2 = &temp2;
14439 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14440 }
14441 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14442 if (!SWIG_IsOK(ecode3)) {
14443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14444 }
14445 arg3 = static_cast< byte >(val3);
14446 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14447 if (!SWIG_IsOK(ecode4)) {
14448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14449 }
14450 arg4 = static_cast< byte >(val4);
14451 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14452 if (!SWIG_IsOK(ecode5)) {
14453 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14454 }
14455 arg5 = static_cast< byte >(val5);
14456 {
14457 PyThreadState* __tstate = wxPyBeginAllowThreads();
14458 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14459 wxPyEndAllowThreads(__tstate);
14460 if (PyErr_Occurred()) SWIG_fail;
14461 }
14462 resultobj = SWIG_Py_Void();
14463 return resultobj;
14464 fail:
14465 return NULL;
14466 }
14467
14468
14469 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14470 PyObject *resultobj = 0;
14471 wxImage *arg1 = (wxImage *) 0 ;
14472 int arg2 ;
14473 int arg3 ;
14474 byte result;
14475 void *argp1 = 0 ;
14476 int res1 = 0 ;
14477 int val2 ;
14478 int ecode2 = 0 ;
14479 int val3 ;
14480 int ecode3 = 0 ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 PyObject * obj2 = 0 ;
14484 char * kwnames[] = {
14485 (char *) "self",(char *) "x",(char *) "y", NULL
14486 };
14487
14488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14490 if (!SWIG_IsOK(res1)) {
14491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14492 }
14493 arg1 = reinterpret_cast< wxImage * >(argp1);
14494 ecode2 = SWIG_AsVal_int(obj1, &val2);
14495 if (!SWIG_IsOK(ecode2)) {
14496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14497 }
14498 arg2 = static_cast< int >(val2);
14499 ecode3 = SWIG_AsVal_int(obj2, &val3);
14500 if (!SWIG_IsOK(ecode3)) {
14501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14502 }
14503 arg3 = static_cast< int >(val3);
14504 {
14505 PyThreadState* __tstate = wxPyBeginAllowThreads();
14506 result = (byte)(arg1)->GetRed(arg2,arg3);
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14511 return resultobj;
14512 fail:
14513 return NULL;
14514 }
14515
14516
14517 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14518 PyObject *resultobj = 0;
14519 wxImage *arg1 = (wxImage *) 0 ;
14520 int arg2 ;
14521 int arg3 ;
14522 byte result;
14523 void *argp1 = 0 ;
14524 int res1 = 0 ;
14525 int val2 ;
14526 int ecode2 = 0 ;
14527 int val3 ;
14528 int ecode3 = 0 ;
14529 PyObject * obj0 = 0 ;
14530 PyObject * obj1 = 0 ;
14531 PyObject * obj2 = 0 ;
14532 char * kwnames[] = {
14533 (char *) "self",(char *) "x",(char *) "y", NULL
14534 };
14535
14536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14538 if (!SWIG_IsOK(res1)) {
14539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14540 }
14541 arg1 = reinterpret_cast< wxImage * >(argp1);
14542 ecode2 = SWIG_AsVal_int(obj1, &val2);
14543 if (!SWIG_IsOK(ecode2)) {
14544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14545 }
14546 arg2 = static_cast< int >(val2);
14547 ecode3 = SWIG_AsVal_int(obj2, &val3);
14548 if (!SWIG_IsOK(ecode3)) {
14549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14550 }
14551 arg3 = static_cast< int >(val3);
14552 {
14553 PyThreadState* __tstate = wxPyBeginAllowThreads();
14554 result = (byte)(arg1)->GetGreen(arg2,arg3);
14555 wxPyEndAllowThreads(__tstate);
14556 if (PyErr_Occurred()) SWIG_fail;
14557 }
14558 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14559 return resultobj;
14560 fail:
14561 return NULL;
14562 }
14563
14564
14565 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14566 PyObject *resultobj = 0;
14567 wxImage *arg1 = (wxImage *) 0 ;
14568 int arg2 ;
14569 int arg3 ;
14570 byte result;
14571 void *argp1 = 0 ;
14572 int res1 = 0 ;
14573 int val2 ;
14574 int ecode2 = 0 ;
14575 int val3 ;
14576 int ecode3 = 0 ;
14577 PyObject * obj0 = 0 ;
14578 PyObject * obj1 = 0 ;
14579 PyObject * obj2 = 0 ;
14580 char * kwnames[] = {
14581 (char *) "self",(char *) "x",(char *) "y", NULL
14582 };
14583
14584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14586 if (!SWIG_IsOK(res1)) {
14587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14588 }
14589 arg1 = reinterpret_cast< wxImage * >(argp1);
14590 ecode2 = SWIG_AsVal_int(obj1, &val2);
14591 if (!SWIG_IsOK(ecode2)) {
14592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14593 }
14594 arg2 = static_cast< int >(val2);
14595 ecode3 = SWIG_AsVal_int(obj2, &val3);
14596 if (!SWIG_IsOK(ecode3)) {
14597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14598 }
14599 arg3 = static_cast< int >(val3);
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 result = (byte)(arg1)->GetBlue(arg2,arg3);
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj = 0;
14615 wxImage *arg1 = (wxImage *) 0 ;
14616 int arg2 ;
14617 int arg3 ;
14618 byte arg4 ;
14619 void *argp1 = 0 ;
14620 int res1 = 0 ;
14621 int val2 ;
14622 int ecode2 = 0 ;
14623 int val3 ;
14624 int ecode3 = 0 ;
14625 unsigned char val4 ;
14626 int ecode4 = 0 ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 PyObject * obj2 = 0 ;
14630 PyObject * obj3 = 0 ;
14631 char * kwnames[] = {
14632 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14633 };
14634
14635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14637 if (!SWIG_IsOK(res1)) {
14638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14639 }
14640 arg1 = reinterpret_cast< wxImage * >(argp1);
14641 ecode2 = SWIG_AsVal_int(obj1, &val2);
14642 if (!SWIG_IsOK(ecode2)) {
14643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14644 }
14645 arg2 = static_cast< int >(val2);
14646 ecode3 = SWIG_AsVal_int(obj2, &val3);
14647 if (!SWIG_IsOK(ecode3)) {
14648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14649 }
14650 arg3 = static_cast< int >(val3);
14651 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14652 if (!SWIG_IsOK(ecode4)) {
14653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14654 }
14655 arg4 = static_cast< byte >(val4);
14656 {
14657 PyThreadState* __tstate = wxPyBeginAllowThreads();
14658 (arg1)->SetAlpha(arg2,arg3,arg4);
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 resultobj = SWIG_Py_Void();
14663 return resultobj;
14664 fail:
14665 return NULL;
14666 }
14667
14668
14669 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14670 PyObject *resultobj = 0;
14671 wxImage *arg1 = (wxImage *) 0 ;
14672 int arg2 ;
14673 int arg3 ;
14674 byte result;
14675 void *argp1 = 0 ;
14676 int res1 = 0 ;
14677 int val2 ;
14678 int ecode2 = 0 ;
14679 int val3 ;
14680 int ecode3 = 0 ;
14681 PyObject * obj0 = 0 ;
14682 PyObject * obj1 = 0 ;
14683 PyObject * obj2 = 0 ;
14684 char * kwnames[] = {
14685 (char *) "self",(char *) "x",(char *) "y", NULL
14686 };
14687
14688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14690 if (!SWIG_IsOK(res1)) {
14691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14692 }
14693 arg1 = reinterpret_cast< wxImage * >(argp1);
14694 ecode2 = SWIG_AsVal_int(obj1, &val2);
14695 if (!SWIG_IsOK(ecode2)) {
14696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14697 }
14698 arg2 = static_cast< int >(val2);
14699 ecode3 = SWIG_AsVal_int(obj2, &val3);
14700 if (!SWIG_IsOK(ecode3)) {
14701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14702 }
14703 arg3 = static_cast< int >(val3);
14704 {
14705 PyThreadState* __tstate = wxPyBeginAllowThreads();
14706 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14707 wxPyEndAllowThreads(__tstate);
14708 if (PyErr_Occurred()) SWIG_fail;
14709 }
14710 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14711 return resultobj;
14712 fail:
14713 return NULL;
14714 }
14715
14716
14717 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *resultobj = 0;
14719 wxImage *arg1 = (wxImage *) 0 ;
14720 bool result;
14721 void *argp1 = 0 ;
14722 int res1 = 0 ;
14723 PyObject *swig_obj[1] ;
14724
14725 if (!args) SWIG_fail;
14726 swig_obj[0] = args;
14727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14728 if (!SWIG_IsOK(res1)) {
14729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14730 }
14731 arg1 = reinterpret_cast< wxImage * >(argp1);
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (bool)(arg1)->HasAlpha();
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 {
14739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14740 }
14741 return resultobj;
14742 fail:
14743 return NULL;
14744 }
14745
14746
14747 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14748 PyObject *resultobj = 0;
14749 wxImage *arg1 = (wxImage *) 0 ;
14750 void *argp1 = 0 ;
14751 int res1 = 0 ;
14752 PyObject *swig_obj[1] ;
14753
14754 if (!args) SWIG_fail;
14755 swig_obj[0] = args;
14756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14757 if (!SWIG_IsOK(res1)) {
14758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14759 }
14760 arg1 = reinterpret_cast< wxImage * >(argp1);
14761 {
14762 PyThreadState* __tstate = wxPyBeginAllowThreads();
14763 (arg1)->InitAlpha();
14764 wxPyEndAllowThreads(__tstate);
14765 if (PyErr_Occurred()) SWIG_fail;
14766 }
14767 resultobj = SWIG_Py_Void();
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj = 0;
14776 wxImage *arg1 = (wxImage *) 0 ;
14777 int arg2 ;
14778 int arg3 ;
14779 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14780 bool result;
14781 void *argp1 = 0 ;
14782 int res1 = 0 ;
14783 int val2 ;
14784 int ecode2 = 0 ;
14785 int val3 ;
14786 int ecode3 = 0 ;
14787 unsigned char val4 ;
14788 int ecode4 = 0 ;
14789 PyObject * obj0 = 0 ;
14790 PyObject * obj1 = 0 ;
14791 PyObject * obj2 = 0 ;
14792 PyObject * obj3 = 0 ;
14793 char * kwnames[] = {
14794 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14795 };
14796
14797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14799 if (!SWIG_IsOK(res1)) {
14800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14801 }
14802 arg1 = reinterpret_cast< wxImage * >(argp1);
14803 ecode2 = SWIG_AsVal_int(obj1, &val2);
14804 if (!SWIG_IsOK(ecode2)) {
14805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14806 }
14807 arg2 = static_cast< int >(val2);
14808 ecode3 = SWIG_AsVal_int(obj2, &val3);
14809 if (!SWIG_IsOK(ecode3)) {
14810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14811 }
14812 arg3 = static_cast< int >(val3);
14813 if (obj3) {
14814 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14815 if (!SWIG_IsOK(ecode4)) {
14816 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14817 }
14818 arg4 = static_cast< byte >(val4);
14819 }
14820 {
14821 PyThreadState* __tstate = wxPyBeginAllowThreads();
14822 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14823 wxPyEndAllowThreads(__tstate);
14824 if (PyErr_Occurred()) SWIG_fail;
14825 }
14826 {
14827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14828 }
14829 return resultobj;
14830 fail:
14831 return NULL;
14832 }
14833
14834
14835 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14836 PyObject *resultobj = 0;
14837 wxImage *arg1 = (wxImage *) 0 ;
14838 byte *arg2 = (byte *) 0 ;
14839 byte *arg3 = (byte *) 0 ;
14840 byte *arg4 = (byte *) 0 ;
14841 byte arg5 = (byte) 0 ;
14842 byte arg6 = (byte) 0 ;
14843 byte arg7 = (byte) 0 ;
14844 bool result;
14845 void *argp1 = 0 ;
14846 int res1 = 0 ;
14847 byte temp2 ;
14848 int res2 = SWIG_TMPOBJ ;
14849 byte temp3 ;
14850 int res3 = SWIG_TMPOBJ ;
14851 byte temp4 ;
14852 int res4 = SWIG_TMPOBJ ;
14853 unsigned char val5 ;
14854 int ecode5 = 0 ;
14855 unsigned char val6 ;
14856 int ecode6 = 0 ;
14857 unsigned char val7 ;
14858 int ecode7 = 0 ;
14859 PyObject * obj0 = 0 ;
14860 PyObject * obj1 = 0 ;
14861 PyObject * obj2 = 0 ;
14862 PyObject * obj3 = 0 ;
14863 char * kwnames[] = {
14864 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14865 };
14866
14867 arg2 = &temp2;
14868 arg3 = &temp3;
14869 arg4 = &temp4;
14870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14872 if (!SWIG_IsOK(res1)) {
14873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14874 }
14875 arg1 = reinterpret_cast< wxImage * >(argp1);
14876 if (obj1) {
14877 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14878 if (!SWIG_IsOK(ecode5)) {
14879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14880 }
14881 arg5 = static_cast< byte >(val5);
14882 }
14883 if (obj2) {
14884 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14885 if (!SWIG_IsOK(ecode6)) {
14886 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14887 }
14888 arg6 = static_cast< byte >(val6);
14889 }
14890 if (obj3) {
14891 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14892 if (!SWIG_IsOK(ecode7)) {
14893 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14894 }
14895 arg7 = static_cast< byte >(val7);
14896 }
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14900 wxPyEndAllowThreads(__tstate);
14901 if (PyErr_Occurred()) SWIG_fail;
14902 }
14903 {
14904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14905 }
14906 if (SWIG_IsTmpObj(res2)) {
14907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14908 } else {
14909 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14911 }
14912 if (SWIG_IsTmpObj(res3)) {
14913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14914 } else {
14915 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14917 }
14918 if (SWIG_IsTmpObj(res4)) {
14919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14920 } else {
14921 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14923 }
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj = 0;
14932 wxImage *arg1 = (wxImage *) 0 ;
14933 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14934 bool result;
14935 void *argp1 = 0 ;
14936 int res1 = 0 ;
14937 unsigned char val2 ;
14938 int ecode2 = 0 ;
14939 PyObject * obj0 = 0 ;
14940 PyObject * obj1 = 0 ;
14941 char * kwnames[] = {
14942 (char *) "self",(char *) "threshold", NULL
14943 };
14944
14945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14947 if (!SWIG_IsOK(res1)) {
14948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14949 }
14950 arg1 = reinterpret_cast< wxImage * >(argp1);
14951 if (obj1) {
14952 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14953 if (!SWIG_IsOK(ecode2)) {
14954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14955 }
14956 arg2 = static_cast< byte >(val2);
14957 }
14958 {
14959 PyThreadState* __tstate = wxPyBeginAllowThreads();
14960 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 {
14965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14966 }
14967 return resultobj;
14968 fail:
14969 return NULL;
14970 }
14971
14972
14973 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj = 0;
14975 wxImage *arg1 = (wxImage *) 0 ;
14976 byte arg2 ;
14977 byte arg3 ;
14978 byte arg4 ;
14979 bool result;
14980 void *argp1 = 0 ;
14981 int res1 = 0 ;
14982 unsigned char val2 ;
14983 int ecode2 = 0 ;
14984 unsigned char val3 ;
14985 int ecode3 = 0 ;
14986 unsigned char val4 ;
14987 int ecode4 = 0 ;
14988 PyObject * obj0 = 0 ;
14989 PyObject * obj1 = 0 ;
14990 PyObject * obj2 = 0 ;
14991 PyObject * obj3 = 0 ;
14992 char * kwnames[] = {
14993 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14994 };
14995
14996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14998 if (!SWIG_IsOK(res1)) {
14999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15000 }
15001 arg1 = reinterpret_cast< wxImage * >(argp1);
15002 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15003 if (!SWIG_IsOK(ecode2)) {
15004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15005 }
15006 arg2 = static_cast< byte >(val2);
15007 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15008 if (!SWIG_IsOK(ecode3)) {
15009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15010 }
15011 arg3 = static_cast< byte >(val3);
15012 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15013 if (!SWIG_IsOK(ecode4)) {
15014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15015 }
15016 arg4 = static_cast< byte >(val4);
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 {
15024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15025 }
15026 return resultobj;
15027 fail:
15028 return NULL;
15029 }
15030
15031
15032 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15033 PyObject *resultobj = 0;
15034 wxImage *arg1 = (wxImage *) 0 ;
15035 wxImage *arg2 = 0 ;
15036 byte arg3 ;
15037 byte arg4 ;
15038 byte arg5 ;
15039 bool result;
15040 void *argp1 = 0 ;
15041 int res1 = 0 ;
15042 void *argp2 = 0 ;
15043 int res2 = 0 ;
15044 unsigned char val3 ;
15045 int ecode3 = 0 ;
15046 unsigned char val4 ;
15047 int ecode4 = 0 ;
15048 unsigned char val5 ;
15049 int ecode5 = 0 ;
15050 PyObject * obj0 = 0 ;
15051 PyObject * obj1 = 0 ;
15052 PyObject * obj2 = 0 ;
15053 PyObject * obj3 = 0 ;
15054 PyObject * obj4 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImage * >(argp1);
15065 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15066 if (!SWIG_IsOK(res2)) {
15067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15068 }
15069 if (!argp2) {
15070 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15071 }
15072 arg2 = reinterpret_cast< wxImage * >(argp2);
15073 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15074 if (!SWIG_IsOK(ecode3)) {
15075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15076 }
15077 arg3 = static_cast< byte >(val3);
15078 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15079 if (!SWIG_IsOK(ecode4)) {
15080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15081 }
15082 arg4 = static_cast< byte >(val4);
15083 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15084 if (!SWIG_IsOK(ecode5)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15086 }
15087 arg5 = static_cast< byte >(val5);
15088 {
15089 PyThreadState* __tstate = wxPyBeginAllowThreads();
15090 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15091 wxPyEndAllowThreads(__tstate);
15092 if (PyErr_Occurred()) SWIG_fail;
15093 }
15094 {
15095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15096 }
15097 return resultobj;
15098 fail:
15099 return NULL;
15100 }
15101
15102
15103 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15104 PyObject *resultobj = 0;
15105 wxString *arg1 = 0 ;
15106 bool result;
15107 bool temp1 = false ;
15108 PyObject * obj0 = 0 ;
15109 char * kwnames[] = {
15110 (char *) "filename", NULL
15111 };
15112
15113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15114 {
15115 arg1 = wxString_in_helper(obj0);
15116 if (arg1 == NULL) SWIG_fail;
15117 temp1 = true;
15118 }
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15122 wxPyEndAllowThreads(__tstate);
15123 if (PyErr_Occurred()) SWIG_fail;
15124 }
15125 {
15126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15127 }
15128 {
15129 if (temp1)
15130 delete arg1;
15131 }
15132 return resultobj;
15133 fail:
15134 {
15135 if (temp1)
15136 delete arg1;
15137 }
15138 return NULL;
15139 }
15140
15141
15142 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15143 PyObject *resultobj = 0;
15144 wxString *arg1 = 0 ;
15145 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15146 int result;
15147 bool temp1 = false ;
15148 long val2 ;
15149 int ecode2 = 0 ;
15150 PyObject * obj0 = 0 ;
15151 PyObject * obj1 = 0 ;
15152 char * kwnames[] = {
15153 (char *) "filename",(char *) "type", NULL
15154 };
15155
15156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15157 {
15158 arg1 = wxString_in_helper(obj0);
15159 if (arg1 == NULL) SWIG_fail;
15160 temp1 = true;
15161 }
15162 if (obj1) {
15163 ecode2 = SWIG_AsVal_long(obj1, &val2);
15164 if (!SWIG_IsOK(ecode2)) {
15165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15166 }
15167 arg2 = static_cast< long >(val2);
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_From_int(static_cast< int >(result));
15176 {
15177 if (temp1)
15178 delete arg1;
15179 }
15180 return resultobj;
15181 fail:
15182 {
15183 if (temp1)
15184 delete arg1;
15185 }
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj = 0;
15192 wxImage *arg1 = (wxImage *) 0 ;
15193 wxString *arg2 = 0 ;
15194 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15195 int arg4 = (int) -1 ;
15196 bool result;
15197 void *argp1 = 0 ;
15198 int res1 = 0 ;
15199 bool temp2 = false ;
15200 long val3 ;
15201 int ecode3 = 0 ;
15202 int val4 ;
15203 int ecode4 = 0 ;
15204 PyObject * obj0 = 0 ;
15205 PyObject * obj1 = 0 ;
15206 PyObject * obj2 = 0 ;
15207 PyObject * obj3 = 0 ;
15208 char * kwnames[] = {
15209 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15210 };
15211
15212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 arg2 = wxString_in_helper(obj1);
15220 if (arg2 == NULL) SWIG_fail;
15221 temp2 = true;
15222 }
15223 if (obj2) {
15224 ecode3 = SWIG_AsVal_long(obj2, &val3);
15225 if (!SWIG_IsOK(ecode3)) {
15226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15227 }
15228 arg3 = static_cast< long >(val3);
15229 }
15230 if (obj3) {
15231 ecode4 = SWIG_AsVal_int(obj3, &val4);
15232 if (!SWIG_IsOK(ecode4)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15234 }
15235 arg4 = static_cast< int >(val4);
15236 }
15237 {
15238 PyThreadState* __tstate = wxPyBeginAllowThreads();
15239 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15240 wxPyEndAllowThreads(__tstate);
15241 if (PyErr_Occurred()) SWIG_fail;
15242 }
15243 {
15244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15245 }
15246 {
15247 if (temp2)
15248 delete arg2;
15249 }
15250 return resultobj;
15251 fail:
15252 {
15253 if (temp2)
15254 delete arg2;
15255 }
15256 return NULL;
15257 }
15258
15259
15260 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj = 0;
15262 wxImage *arg1 = (wxImage *) 0 ;
15263 wxString *arg2 = 0 ;
15264 wxString *arg3 = 0 ;
15265 int arg4 = (int) -1 ;
15266 bool result;
15267 void *argp1 = 0 ;
15268 int res1 = 0 ;
15269 bool temp2 = false ;
15270 bool temp3 = false ;
15271 int val4 ;
15272 int ecode4 = 0 ;
15273 PyObject * obj0 = 0 ;
15274 PyObject * obj1 = 0 ;
15275 PyObject * obj2 = 0 ;
15276 PyObject * obj3 = 0 ;
15277 char * kwnames[] = {
15278 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15279 };
15280
15281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15285 }
15286 arg1 = reinterpret_cast< wxImage * >(argp1);
15287 {
15288 arg2 = wxString_in_helper(obj1);
15289 if (arg2 == NULL) SWIG_fail;
15290 temp2 = true;
15291 }
15292 {
15293 arg3 = wxString_in_helper(obj2);
15294 if (arg3 == NULL) SWIG_fail;
15295 temp3 = true;
15296 }
15297 if (obj3) {
15298 ecode4 = SWIG_AsVal_int(obj3, &val4);
15299 if (!SWIG_IsOK(ecode4)) {
15300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15301 }
15302 arg4 = static_cast< int >(val4);
15303 }
15304 {
15305 PyThreadState* __tstate = wxPyBeginAllowThreads();
15306 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15307 wxPyEndAllowThreads(__tstate);
15308 if (PyErr_Occurred()) SWIG_fail;
15309 }
15310 {
15311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15312 }
15313 {
15314 if (temp2)
15315 delete arg2;
15316 }
15317 {
15318 if (temp3)
15319 delete arg3;
15320 }
15321 return resultobj;
15322 fail:
15323 {
15324 if (temp2)
15325 delete arg2;
15326 }
15327 {
15328 if (temp3)
15329 delete arg3;
15330 }
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15336 PyObject *resultobj = 0;
15337 wxImage *arg1 = (wxImage *) 0 ;
15338 wxString *arg2 = 0 ;
15339 int arg3 ;
15340 bool result;
15341 void *argp1 = 0 ;
15342 int res1 = 0 ;
15343 bool temp2 = false ;
15344 int val3 ;
15345 int ecode3 = 0 ;
15346 PyObject * obj0 = 0 ;
15347 PyObject * obj1 = 0 ;
15348 PyObject * obj2 = 0 ;
15349 char * kwnames[] = {
15350 (char *) "self",(char *) "name",(char *) "type", NULL
15351 };
15352
15353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15355 if (!SWIG_IsOK(res1)) {
15356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15357 }
15358 arg1 = reinterpret_cast< wxImage * >(argp1);
15359 {
15360 arg2 = wxString_in_helper(obj1);
15361 if (arg2 == NULL) SWIG_fail;
15362 temp2 = true;
15363 }
15364 ecode3 = SWIG_AsVal_int(obj2, &val3);
15365 if (!SWIG_IsOK(ecode3)) {
15366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15367 }
15368 arg3 = static_cast< int >(val3);
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15372 wxPyEndAllowThreads(__tstate);
15373 if (PyErr_Occurred()) SWIG_fail;
15374 }
15375 {
15376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15377 }
15378 {
15379 if (temp2)
15380 delete arg2;
15381 }
15382 return resultobj;
15383 fail:
15384 {
15385 if (temp2)
15386 delete arg2;
15387 }
15388 return NULL;
15389 }
15390
15391
15392 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15393 PyObject *resultobj = 0;
15394 wxImage *arg1 = (wxImage *) 0 ;
15395 wxString *arg2 = 0 ;
15396 wxString *arg3 = 0 ;
15397 bool result;
15398 void *argp1 = 0 ;
15399 int res1 = 0 ;
15400 bool temp2 = false ;
15401 bool temp3 = false ;
15402 PyObject * obj0 = 0 ;
15403 PyObject * obj1 = 0 ;
15404 PyObject * obj2 = 0 ;
15405 char * kwnames[] = {
15406 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15407 };
15408
15409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15411 if (!SWIG_IsOK(res1)) {
15412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15413 }
15414 arg1 = reinterpret_cast< wxImage * >(argp1);
15415 {
15416 arg2 = wxString_in_helper(obj1);
15417 if (arg2 == NULL) SWIG_fail;
15418 temp2 = true;
15419 }
15420 {
15421 arg3 = wxString_in_helper(obj2);
15422 if (arg3 == NULL) SWIG_fail;
15423 temp3 = true;
15424 }
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 {
15432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15433 }
15434 {
15435 if (temp2)
15436 delete arg2;
15437 }
15438 {
15439 if (temp3)
15440 delete arg3;
15441 }
15442 return resultobj;
15443 fail:
15444 {
15445 if (temp2)
15446 delete arg2;
15447 }
15448 {
15449 if (temp3)
15450 delete arg3;
15451 }
15452 return NULL;
15453 }
15454
15455
15456 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15457 PyObject *resultobj = 0;
15458 wxInputStream *arg1 = 0 ;
15459 bool result;
15460 wxPyInputStream *temp1 ;
15461 bool created1 ;
15462 PyObject * obj0 = 0 ;
15463 char * kwnames[] = {
15464 (char *) "stream", NULL
15465 };
15466
15467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15468 {
15469 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15470 arg1 = temp1->m_wxis;
15471 created1 = false;
15472 } else {
15473 PyErr_Clear(); // clear the failure of the wxPyConvert above
15474 arg1 = wxPyCBInputStream_create(obj0, false);
15475 if (arg1 == NULL) {
15476 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15477 SWIG_fail;
15478 }
15479 created1 = true;
15480 }
15481 }
15482 {
15483 PyThreadState* __tstate = wxPyBeginAllowThreads();
15484 result = (bool)wxImage::CanRead(*arg1);
15485 wxPyEndAllowThreads(__tstate);
15486 if (PyErr_Occurred()) SWIG_fail;
15487 }
15488 {
15489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15490 }
15491 {
15492 if (created1) delete arg1;
15493 }
15494 return resultobj;
15495 fail:
15496 {
15497 if (created1) delete arg1;
15498 }
15499 return NULL;
15500 }
15501
15502
15503 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15504 PyObject *resultobj = 0;
15505 wxImage *arg1 = (wxImage *) 0 ;
15506 wxInputStream *arg2 = 0 ;
15507 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15508 int arg4 = (int) -1 ;
15509 bool result;
15510 void *argp1 = 0 ;
15511 int res1 = 0 ;
15512 wxPyInputStream *temp2 ;
15513 bool created2 ;
15514 long val3 ;
15515 int ecode3 = 0 ;
15516 int val4 ;
15517 int ecode4 = 0 ;
15518 PyObject * obj0 = 0 ;
15519 PyObject * obj1 = 0 ;
15520 PyObject * obj2 = 0 ;
15521 PyObject * obj3 = 0 ;
15522 char * kwnames[] = {
15523 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15524 };
15525
15526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15528 if (!SWIG_IsOK(res1)) {
15529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15530 }
15531 arg1 = reinterpret_cast< wxImage * >(argp1);
15532 {
15533 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15534 arg2 = temp2->m_wxis;
15535 created2 = false;
15536 } else {
15537 PyErr_Clear(); // clear the failure of the wxPyConvert above
15538 arg2 = wxPyCBInputStream_create(obj1, false);
15539 if (arg2 == NULL) {
15540 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15541 SWIG_fail;
15542 }
15543 created2 = true;
15544 }
15545 }
15546 if (obj2) {
15547 ecode3 = SWIG_AsVal_long(obj2, &val3);
15548 if (!SWIG_IsOK(ecode3)) {
15549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15550 }
15551 arg3 = static_cast< long >(val3);
15552 }
15553 if (obj3) {
15554 ecode4 = SWIG_AsVal_int(obj3, &val4);
15555 if (!SWIG_IsOK(ecode4)) {
15556 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15557 }
15558 arg4 = static_cast< int >(val4);
15559 }
15560 {
15561 PyThreadState* __tstate = wxPyBeginAllowThreads();
15562 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 {
15567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15568 }
15569 {
15570 if (created2) delete arg2;
15571 }
15572 return resultobj;
15573 fail:
15574 {
15575 if (created2) delete arg2;
15576 }
15577 return NULL;
15578 }
15579
15580
15581 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15582 PyObject *resultobj = 0;
15583 wxImage *arg1 = (wxImage *) 0 ;
15584 wxInputStream *arg2 = 0 ;
15585 wxString *arg3 = 0 ;
15586 int arg4 = (int) -1 ;
15587 bool result;
15588 void *argp1 = 0 ;
15589 int res1 = 0 ;
15590 wxPyInputStream *temp2 ;
15591 bool created2 ;
15592 bool temp3 = false ;
15593 int val4 ;
15594 int ecode4 = 0 ;
15595 PyObject * obj0 = 0 ;
15596 PyObject * obj1 = 0 ;
15597 PyObject * obj2 = 0 ;
15598 PyObject * obj3 = 0 ;
15599 char * kwnames[] = {
15600 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15601 };
15602
15603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15605 if (!SWIG_IsOK(res1)) {
15606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15607 }
15608 arg1 = reinterpret_cast< wxImage * >(argp1);
15609 {
15610 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15611 arg2 = temp2->m_wxis;
15612 created2 = false;
15613 } else {
15614 PyErr_Clear(); // clear the failure of the wxPyConvert above
15615 arg2 = wxPyCBInputStream_create(obj1, false);
15616 if (arg2 == NULL) {
15617 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15618 SWIG_fail;
15619 }
15620 created2 = true;
15621 }
15622 }
15623 {
15624 arg3 = wxString_in_helper(obj2);
15625 if (arg3 == NULL) SWIG_fail;
15626 temp3 = true;
15627 }
15628 if (obj3) {
15629 ecode4 = SWIG_AsVal_int(obj3, &val4);
15630 if (!SWIG_IsOK(ecode4)) {
15631 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15632 }
15633 arg4 = static_cast< int >(val4);
15634 }
15635 {
15636 PyThreadState* __tstate = wxPyBeginAllowThreads();
15637 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15638 wxPyEndAllowThreads(__tstate);
15639 if (PyErr_Occurred()) SWIG_fail;
15640 }
15641 {
15642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15643 }
15644 {
15645 if (created2) delete arg2;
15646 }
15647 {
15648 if (temp3)
15649 delete arg3;
15650 }
15651 return resultobj;
15652 fail:
15653 {
15654 if (created2) delete arg2;
15655 }
15656 {
15657 if (temp3)
15658 delete arg3;
15659 }
15660 return NULL;
15661 }
15662
15663
15664 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15665 PyObject *resultobj = 0;
15666 wxImage *arg1 = (wxImage *) 0 ;
15667 bool result;
15668 void *argp1 = 0 ;
15669 int res1 = 0 ;
15670 PyObject *swig_obj[1] ;
15671
15672 if (!args) SWIG_fail;
15673 swig_obj[0] = args;
15674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15677 }
15678 arg1 = reinterpret_cast< wxImage * >(argp1);
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 result = (bool)(arg1)->Ok();
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 {
15686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15687 }
15688 return resultobj;
15689 fail:
15690 return NULL;
15691 }
15692
15693
15694 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15695 PyObject *resultobj = 0;
15696 wxImage *arg1 = (wxImage *) 0 ;
15697 int 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_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15707 }
15708 arg1 = reinterpret_cast< wxImage * >(argp1);
15709 {
15710 PyThreadState* __tstate = wxPyBeginAllowThreads();
15711 result = (int)(arg1)->GetWidth();
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 resultobj = SWIG_From_int(static_cast< int >(result));
15716 return resultobj;
15717 fail:
15718 return NULL;
15719 }
15720
15721
15722 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15723 PyObject *resultobj = 0;
15724 wxImage *arg1 = (wxImage *) 0 ;
15725 int result;
15726 void *argp1 = 0 ;
15727 int res1 = 0 ;
15728 PyObject *swig_obj[1] ;
15729
15730 if (!args) SWIG_fail;
15731 swig_obj[0] = args;
15732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15733 if (!SWIG_IsOK(res1)) {
15734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15735 }
15736 arg1 = reinterpret_cast< wxImage * >(argp1);
15737 {
15738 PyThreadState* __tstate = wxPyBeginAllowThreads();
15739 result = (int)(arg1)->GetHeight();
15740 wxPyEndAllowThreads(__tstate);
15741 if (PyErr_Occurred()) SWIG_fail;
15742 }
15743 resultobj = SWIG_From_int(static_cast< int >(result));
15744 return resultobj;
15745 fail:
15746 return NULL;
15747 }
15748
15749
15750 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15751 PyObject *resultobj = 0;
15752 wxImage *arg1 = (wxImage *) 0 ;
15753 wxSize result;
15754 void *argp1 = 0 ;
15755 int res1 = 0 ;
15756 PyObject *swig_obj[1] ;
15757
15758 if (!args) SWIG_fail;
15759 swig_obj[0] = args;
15760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15761 if (!SWIG_IsOK(res1)) {
15762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15763 }
15764 arg1 = reinterpret_cast< wxImage * >(argp1);
15765 {
15766 PyThreadState* __tstate = wxPyBeginAllowThreads();
15767 result = wxImage_GetSize(arg1);
15768 wxPyEndAllowThreads(__tstate);
15769 if (PyErr_Occurred()) SWIG_fail;
15770 }
15771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15772 return resultobj;
15773 fail:
15774 return NULL;
15775 }
15776
15777
15778 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15779 PyObject *resultobj = 0;
15780 wxImage *arg1 = (wxImage *) 0 ;
15781 wxRect *arg2 = 0 ;
15782 SwigValueWrapper<wxImage > result;
15783 void *argp1 = 0 ;
15784 int res1 = 0 ;
15785 wxRect temp2 ;
15786 PyObject * obj0 = 0 ;
15787 PyObject * obj1 = 0 ;
15788 char * kwnames[] = {
15789 (char *) "self",(char *) "rect", NULL
15790 };
15791
15792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15794 if (!SWIG_IsOK(res1)) {
15795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15796 }
15797 arg1 = reinterpret_cast< wxImage * >(argp1);
15798 {
15799 arg2 = &temp2;
15800 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15801 }
15802 {
15803 PyThreadState* __tstate = wxPyBeginAllowThreads();
15804 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj = 0;
15817 wxImage *arg1 = (wxImage *) 0 ;
15818 wxSize *arg2 = 0 ;
15819 wxPoint *arg3 = 0 ;
15820 int arg4 = (int) -1 ;
15821 int arg5 = (int) -1 ;
15822 int arg6 = (int) -1 ;
15823 SwigValueWrapper<wxImage > result;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 wxSize temp2 ;
15827 wxPoint temp3 ;
15828 int val4 ;
15829 int ecode4 = 0 ;
15830 int val5 ;
15831 int ecode5 = 0 ;
15832 int val6 ;
15833 int ecode6 = 0 ;
15834 PyObject * obj0 = 0 ;
15835 PyObject * obj1 = 0 ;
15836 PyObject * obj2 = 0 ;
15837 PyObject * obj3 = 0 ;
15838 PyObject * obj4 = 0 ;
15839 PyObject * obj5 = 0 ;
15840 char * kwnames[] = {
15841 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15842 };
15843
15844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15846 if (!SWIG_IsOK(res1)) {
15847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15848 }
15849 arg1 = reinterpret_cast< wxImage * >(argp1);
15850 {
15851 arg2 = &temp2;
15852 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15853 }
15854 {
15855 arg3 = &temp3;
15856 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15857 }
15858 if (obj3) {
15859 ecode4 = SWIG_AsVal_int(obj3, &val4);
15860 if (!SWIG_IsOK(ecode4)) {
15861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15862 }
15863 arg4 = static_cast< int >(val4);
15864 }
15865 if (obj4) {
15866 ecode5 = SWIG_AsVal_int(obj4, &val5);
15867 if (!SWIG_IsOK(ecode5)) {
15868 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15869 }
15870 arg5 = static_cast< int >(val5);
15871 }
15872 if (obj5) {
15873 ecode6 = SWIG_AsVal_int(obj5, &val6);
15874 if (!SWIG_IsOK(ecode6)) {
15875 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15876 }
15877 arg6 = static_cast< int >(val6);
15878 }
15879 {
15880 PyThreadState* __tstate = wxPyBeginAllowThreads();
15881 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15882 wxPyEndAllowThreads(__tstate);
15883 if (PyErr_Occurred()) SWIG_fail;
15884 }
15885 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15886 return resultobj;
15887 fail:
15888 return NULL;
15889 }
15890
15891
15892 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15893 PyObject *resultobj = 0;
15894 wxImage *arg1 = (wxImage *) 0 ;
15895 SwigValueWrapper<wxImage > result;
15896 void *argp1 = 0 ;
15897 int res1 = 0 ;
15898 PyObject *swig_obj[1] ;
15899
15900 if (!args) SWIG_fail;
15901 swig_obj[0] = args;
15902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15903 if (!SWIG_IsOK(res1)) {
15904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15905 }
15906 arg1 = reinterpret_cast< wxImage * >(argp1);
15907 {
15908 PyThreadState* __tstate = wxPyBeginAllowThreads();
15909 result = (arg1)->Copy();
15910 wxPyEndAllowThreads(__tstate);
15911 if (PyErr_Occurred()) SWIG_fail;
15912 }
15913 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15914 return resultobj;
15915 fail:
15916 return NULL;
15917 }
15918
15919
15920 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15921 PyObject *resultobj = 0;
15922 wxImage *arg1 = (wxImage *) 0 ;
15923 wxImage *arg2 = 0 ;
15924 int arg3 ;
15925 int arg4 ;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 void *argp2 = 0 ;
15929 int res2 = 0 ;
15930 int val3 ;
15931 int ecode3 = 0 ;
15932 int val4 ;
15933 int ecode4 = 0 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 PyObject * obj2 = 0 ;
15937 PyObject * obj3 = 0 ;
15938 char * kwnames[] = {
15939 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15940 };
15941
15942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15944 if (!SWIG_IsOK(res1)) {
15945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15946 }
15947 arg1 = reinterpret_cast< wxImage * >(argp1);
15948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15949 if (!SWIG_IsOK(res2)) {
15950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15951 }
15952 if (!argp2) {
15953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15954 }
15955 arg2 = reinterpret_cast< wxImage * >(argp2);
15956 ecode3 = SWIG_AsVal_int(obj2, &val3);
15957 if (!SWIG_IsOK(ecode3)) {
15958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15959 }
15960 arg3 = static_cast< int >(val3);
15961 ecode4 = SWIG_AsVal_int(obj3, &val4);
15962 if (!SWIG_IsOK(ecode4)) {
15963 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15964 }
15965 arg4 = static_cast< int >(val4);
15966 {
15967 PyThreadState* __tstate = wxPyBeginAllowThreads();
15968 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15969 wxPyEndAllowThreads(__tstate);
15970 if (PyErr_Occurred()) SWIG_fail;
15971 }
15972 resultobj = SWIG_Py_Void();
15973 return resultobj;
15974 fail:
15975 return NULL;
15976 }
15977
15978
15979 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15980 PyObject *resultobj = 0;
15981 wxImage *arg1 = (wxImage *) 0 ;
15982 PyObject *result = 0 ;
15983 void *argp1 = 0 ;
15984 int res1 = 0 ;
15985 PyObject *swig_obj[1] ;
15986
15987 if (!args) SWIG_fail;
15988 swig_obj[0] = args;
15989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15990 if (!SWIG_IsOK(res1)) {
15991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15992 }
15993 arg1 = reinterpret_cast< wxImage * >(argp1);
15994 {
15995 PyThreadState* __tstate = wxPyBeginAllowThreads();
15996 result = (PyObject *)wxImage_GetData(arg1);
15997 wxPyEndAllowThreads(__tstate);
15998 if (PyErr_Occurred()) SWIG_fail;
15999 }
16000 resultobj = result;
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16008 PyObject *resultobj = 0;
16009 wxImage *arg1 = (wxImage *) 0 ;
16010 buffer arg2 ;
16011 int arg3 ;
16012 void *argp1 = 0 ;
16013 int res1 = 0 ;
16014 Py_ssize_t temp2 ;
16015 PyObject * obj0 = 0 ;
16016 PyObject * obj1 = 0 ;
16017 char * kwnames[] = {
16018 (char *) "self",(char *) "data", NULL
16019 };
16020
16021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16023 if (!SWIG_IsOK(res1)) {
16024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16025 }
16026 arg1 = reinterpret_cast< wxImage * >(argp1);
16027 {
16028 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16029 arg3 = (int)temp2;
16030 }
16031 {
16032 PyThreadState* __tstate = wxPyBeginAllowThreads();
16033 wxImage_SetData(arg1,arg2,arg3);
16034 wxPyEndAllowThreads(__tstate);
16035 if (PyErr_Occurred()) SWIG_fail;
16036 }
16037 resultobj = SWIG_Py_Void();
16038 return resultobj;
16039 fail:
16040 return NULL;
16041 }
16042
16043
16044 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16045 PyObject *resultobj = 0;
16046 wxImage *arg1 = (wxImage *) 0 ;
16047 PyObject *result = 0 ;
16048 void *argp1 = 0 ;
16049 int res1 = 0 ;
16050 PyObject *swig_obj[1] ;
16051
16052 if (!args) SWIG_fail;
16053 swig_obj[0] = args;
16054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16055 if (!SWIG_IsOK(res1)) {
16056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16057 }
16058 arg1 = reinterpret_cast< wxImage * >(argp1);
16059 {
16060 PyThreadState* __tstate = wxPyBeginAllowThreads();
16061 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16062 wxPyEndAllowThreads(__tstate);
16063 if (PyErr_Occurred()) SWIG_fail;
16064 }
16065 resultobj = result;
16066 return resultobj;
16067 fail:
16068 return NULL;
16069 }
16070
16071
16072 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16073 PyObject *resultobj = 0;
16074 wxImage *arg1 = (wxImage *) 0 ;
16075 buffer arg2 ;
16076 int arg3 ;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 Py_ssize_t temp2 ;
16080 PyObject * obj0 = 0 ;
16081 PyObject * obj1 = 0 ;
16082 char * kwnames[] = {
16083 (char *) "self",(char *) "data", NULL
16084 };
16085
16086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16088 if (!SWIG_IsOK(res1)) {
16089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16090 }
16091 arg1 = reinterpret_cast< wxImage * >(argp1);
16092 {
16093 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16094 arg3 = (int)temp2;
16095 }
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 wxImage_SetDataBuffer(arg1,arg2,arg3);
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_Py_Void();
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16110 PyObject *resultobj = 0;
16111 wxImage *arg1 = (wxImage *) 0 ;
16112 PyObject *result = 0 ;
16113 void *argp1 = 0 ;
16114 int res1 = 0 ;
16115 PyObject *swig_obj[1] ;
16116
16117 if (!args) SWIG_fail;
16118 swig_obj[0] = args;
16119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16122 }
16123 arg1 = reinterpret_cast< wxImage * >(argp1);
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (PyObject *)wxImage_GetAlphaData(arg1);
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 resultobj = result;
16131 return resultobj;
16132 fail:
16133 return NULL;
16134 }
16135
16136
16137 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16138 PyObject *resultobj = 0;
16139 wxImage *arg1 = (wxImage *) 0 ;
16140 buffer arg2 ;
16141 int arg3 ;
16142 void *argp1 = 0 ;
16143 int res1 = 0 ;
16144 Py_ssize_t temp2 ;
16145 PyObject * obj0 = 0 ;
16146 PyObject * obj1 = 0 ;
16147 char * kwnames[] = {
16148 (char *) "self",(char *) "alpha", NULL
16149 };
16150
16151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16153 if (!SWIG_IsOK(res1)) {
16154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16155 }
16156 arg1 = reinterpret_cast< wxImage * >(argp1);
16157 {
16158 if (obj1 != Py_None) {
16159 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16160 arg3 = (int)temp2;
16161 }
16162 }
16163 {
16164 PyThreadState* __tstate = wxPyBeginAllowThreads();
16165 wxImage_SetAlphaData(arg1,arg2,arg3);
16166 wxPyEndAllowThreads(__tstate);
16167 if (PyErr_Occurred()) SWIG_fail;
16168 }
16169 resultobj = SWIG_Py_Void();
16170 return resultobj;
16171 fail:
16172 return NULL;
16173 }
16174
16175
16176 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16177 PyObject *resultobj = 0;
16178 wxImage *arg1 = (wxImage *) 0 ;
16179 PyObject *result = 0 ;
16180 void *argp1 = 0 ;
16181 int res1 = 0 ;
16182 PyObject *swig_obj[1] ;
16183
16184 if (!args) SWIG_fail;
16185 swig_obj[0] = args;
16186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16187 if (!SWIG_IsOK(res1)) {
16188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16189 }
16190 arg1 = reinterpret_cast< wxImage * >(argp1);
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = result;
16198 return resultobj;
16199 fail:
16200 return NULL;
16201 }
16202
16203
16204 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16205 PyObject *resultobj = 0;
16206 wxImage *arg1 = (wxImage *) 0 ;
16207 buffer arg2 ;
16208 int arg3 ;
16209 void *argp1 = 0 ;
16210 int res1 = 0 ;
16211 Py_ssize_t temp2 ;
16212 PyObject * obj0 = 0 ;
16213 PyObject * obj1 = 0 ;
16214 char * kwnames[] = {
16215 (char *) "self",(char *) "alpha", NULL
16216 };
16217
16218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16220 if (!SWIG_IsOK(res1)) {
16221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16222 }
16223 arg1 = reinterpret_cast< wxImage * >(argp1);
16224 {
16225 if (obj1 != Py_None) {
16226 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16227 arg3 = (int)temp2;
16228 }
16229 }
16230 {
16231 PyThreadState* __tstate = wxPyBeginAllowThreads();
16232 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16233 wxPyEndAllowThreads(__tstate);
16234 if (PyErr_Occurred()) SWIG_fail;
16235 }
16236 resultobj = SWIG_Py_Void();
16237 return resultobj;
16238 fail:
16239 return NULL;
16240 }
16241
16242
16243 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16244 PyObject *resultobj = 0;
16245 wxImage *arg1 = (wxImage *) 0 ;
16246 byte arg2 ;
16247 byte arg3 ;
16248 byte arg4 ;
16249 void *argp1 = 0 ;
16250 int res1 = 0 ;
16251 unsigned char val2 ;
16252 int ecode2 = 0 ;
16253 unsigned char val3 ;
16254 int ecode3 = 0 ;
16255 unsigned char val4 ;
16256 int ecode4 = 0 ;
16257 PyObject * obj0 = 0 ;
16258 PyObject * obj1 = 0 ;
16259 PyObject * obj2 = 0 ;
16260 PyObject * obj3 = 0 ;
16261 char * kwnames[] = {
16262 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16263 };
16264
16265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16267 if (!SWIG_IsOK(res1)) {
16268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16269 }
16270 arg1 = reinterpret_cast< wxImage * >(argp1);
16271 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16272 if (!SWIG_IsOK(ecode2)) {
16273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16274 }
16275 arg2 = static_cast< byte >(val2);
16276 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16277 if (!SWIG_IsOK(ecode3)) {
16278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16279 }
16280 arg3 = static_cast< byte >(val3);
16281 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16282 if (!SWIG_IsOK(ecode4)) {
16283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16284 }
16285 arg4 = static_cast< byte >(val4);
16286 {
16287 PyThreadState* __tstate = wxPyBeginAllowThreads();
16288 (arg1)->SetMaskColour(arg2,arg3,arg4);
16289 wxPyEndAllowThreads(__tstate);
16290 if (PyErr_Occurred()) SWIG_fail;
16291 }
16292 resultobj = SWIG_Py_Void();
16293 return resultobj;
16294 fail:
16295 return NULL;
16296 }
16297
16298
16299 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16300 PyObject *resultobj = 0;
16301 wxImage *arg1 = (wxImage *) 0 ;
16302 byte *arg2 = (byte *) 0 ;
16303 byte *arg3 = (byte *) 0 ;
16304 byte *arg4 = (byte *) 0 ;
16305 void *argp1 = 0 ;
16306 int res1 = 0 ;
16307 byte temp2 ;
16308 int res2 = SWIG_TMPOBJ ;
16309 byte temp3 ;
16310 int res3 = SWIG_TMPOBJ ;
16311 byte temp4 ;
16312 int res4 = SWIG_TMPOBJ ;
16313 PyObject *swig_obj[1] ;
16314
16315 arg2 = &temp2;
16316 arg3 = &temp3;
16317 arg4 = &temp4;
16318 if (!args) SWIG_fail;
16319 swig_obj[0] = args;
16320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16321 if (!SWIG_IsOK(res1)) {
16322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16323 }
16324 arg1 = reinterpret_cast< wxImage * >(argp1);
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16328 wxPyEndAllowThreads(__tstate);
16329 if (PyErr_Occurred()) SWIG_fail;
16330 }
16331 resultobj = SWIG_Py_Void();
16332 if (SWIG_IsTmpObj(res2)) {
16333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16334 } else {
16335 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16337 }
16338 if (SWIG_IsTmpObj(res3)) {
16339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16340 } else {
16341 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16343 }
16344 if (SWIG_IsTmpObj(res4)) {
16345 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16346 } else {
16347 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16349 }
16350 return resultobj;
16351 fail:
16352 return NULL;
16353 }
16354
16355
16356 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16357 PyObject *resultobj = 0;
16358 wxImage *arg1 = (wxImage *) 0 ;
16359 byte result;
16360 void *argp1 = 0 ;
16361 int res1 = 0 ;
16362 PyObject *swig_obj[1] ;
16363
16364 if (!args) SWIG_fail;
16365 swig_obj[0] = args;
16366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16367 if (!SWIG_IsOK(res1)) {
16368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16369 }
16370 arg1 = reinterpret_cast< wxImage * >(argp1);
16371 {
16372 PyThreadState* __tstate = wxPyBeginAllowThreads();
16373 result = (byte)(arg1)->GetMaskRed();
16374 wxPyEndAllowThreads(__tstate);
16375 if (PyErr_Occurred()) SWIG_fail;
16376 }
16377 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16385 PyObject *resultobj = 0;
16386 wxImage *arg1 = (wxImage *) 0 ;
16387 byte result;
16388 void *argp1 = 0 ;
16389 int res1 = 0 ;
16390 PyObject *swig_obj[1] ;
16391
16392 if (!args) SWIG_fail;
16393 swig_obj[0] = args;
16394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16395 if (!SWIG_IsOK(res1)) {
16396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16397 }
16398 arg1 = reinterpret_cast< wxImage * >(argp1);
16399 {
16400 PyThreadState* __tstate = wxPyBeginAllowThreads();
16401 result = (byte)(arg1)->GetMaskGreen();
16402 wxPyEndAllowThreads(__tstate);
16403 if (PyErr_Occurred()) SWIG_fail;
16404 }
16405 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16406 return resultobj;
16407 fail:
16408 return NULL;
16409 }
16410
16411
16412 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16413 PyObject *resultobj = 0;
16414 wxImage *arg1 = (wxImage *) 0 ;
16415 byte result;
16416 void *argp1 = 0 ;
16417 int res1 = 0 ;
16418 PyObject *swig_obj[1] ;
16419
16420 if (!args) SWIG_fail;
16421 swig_obj[0] = args;
16422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16423 if (!SWIG_IsOK(res1)) {
16424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16425 }
16426 arg1 = reinterpret_cast< wxImage * >(argp1);
16427 {
16428 PyThreadState* __tstate = wxPyBeginAllowThreads();
16429 result = (byte)(arg1)->GetMaskBlue();
16430 wxPyEndAllowThreads(__tstate);
16431 if (PyErr_Occurred()) SWIG_fail;
16432 }
16433 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16434 return resultobj;
16435 fail:
16436 return NULL;
16437 }
16438
16439
16440 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16441 PyObject *resultobj = 0;
16442 wxImage *arg1 = (wxImage *) 0 ;
16443 bool arg2 = (bool) true ;
16444 void *argp1 = 0 ;
16445 int res1 = 0 ;
16446 bool val2 ;
16447 int ecode2 = 0 ;
16448 PyObject * obj0 = 0 ;
16449 PyObject * obj1 = 0 ;
16450 char * kwnames[] = {
16451 (char *) "self",(char *) "mask", NULL
16452 };
16453
16454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16456 if (!SWIG_IsOK(res1)) {
16457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16458 }
16459 arg1 = reinterpret_cast< wxImage * >(argp1);
16460 if (obj1) {
16461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16462 if (!SWIG_IsOK(ecode2)) {
16463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16464 }
16465 arg2 = static_cast< bool >(val2);
16466 }
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 (arg1)->SetMask(arg2);
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 resultobj = SWIG_Py_Void();
16474 return resultobj;
16475 fail:
16476 return NULL;
16477 }
16478
16479
16480 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16481 PyObject *resultobj = 0;
16482 wxImage *arg1 = (wxImage *) 0 ;
16483 bool result;
16484 void *argp1 = 0 ;
16485 int res1 = 0 ;
16486 PyObject *swig_obj[1] ;
16487
16488 if (!args) SWIG_fail;
16489 swig_obj[0] = args;
16490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16491 if (!SWIG_IsOK(res1)) {
16492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16493 }
16494 arg1 = reinterpret_cast< wxImage * >(argp1);
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 result = (bool)(arg1)->HasMask();
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 {
16502 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16503 }
16504 return resultobj;
16505 fail:
16506 return NULL;
16507 }
16508
16509
16510 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16511 PyObject *resultobj = 0;
16512 wxImage *arg1 = (wxImage *) 0 ;
16513 double arg2 ;
16514 wxPoint *arg3 = 0 ;
16515 bool arg4 = (bool) true ;
16516 wxPoint *arg5 = (wxPoint *) NULL ;
16517 SwigValueWrapper<wxImage > result;
16518 void *argp1 = 0 ;
16519 int res1 = 0 ;
16520 double val2 ;
16521 int ecode2 = 0 ;
16522 wxPoint temp3 ;
16523 bool val4 ;
16524 int ecode4 = 0 ;
16525 void *argp5 = 0 ;
16526 int res5 = 0 ;
16527 PyObject * obj0 = 0 ;
16528 PyObject * obj1 = 0 ;
16529 PyObject * obj2 = 0 ;
16530 PyObject * obj3 = 0 ;
16531 PyObject * obj4 = 0 ;
16532 char * kwnames[] = {
16533 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16534 };
16535
16536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16538 if (!SWIG_IsOK(res1)) {
16539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16540 }
16541 arg1 = reinterpret_cast< wxImage * >(argp1);
16542 ecode2 = SWIG_AsVal_double(obj1, &val2);
16543 if (!SWIG_IsOK(ecode2)) {
16544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16545 }
16546 arg2 = static_cast< double >(val2);
16547 {
16548 arg3 = &temp3;
16549 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16550 }
16551 if (obj3) {
16552 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16553 if (!SWIG_IsOK(ecode4)) {
16554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16555 }
16556 arg4 = static_cast< bool >(val4);
16557 }
16558 if (obj4) {
16559 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16560 if (!SWIG_IsOK(res5)) {
16561 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16562 }
16563 arg5 = reinterpret_cast< wxPoint * >(argp5);
16564 }
16565 {
16566 PyThreadState* __tstate = wxPyBeginAllowThreads();
16567 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16568 wxPyEndAllowThreads(__tstate);
16569 if (PyErr_Occurred()) SWIG_fail;
16570 }
16571 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16572 return resultobj;
16573 fail:
16574 return NULL;
16575 }
16576
16577
16578 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16579 PyObject *resultobj = 0;
16580 wxImage *arg1 = (wxImage *) 0 ;
16581 bool arg2 = (bool) true ;
16582 SwigValueWrapper<wxImage > result;
16583 void *argp1 = 0 ;
16584 int res1 = 0 ;
16585 bool val2 ;
16586 int ecode2 = 0 ;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 char * kwnames[] = {
16590 (char *) "self",(char *) "clockwise", NULL
16591 };
16592
16593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16595 if (!SWIG_IsOK(res1)) {
16596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16597 }
16598 arg1 = reinterpret_cast< wxImage * >(argp1);
16599 if (obj1) {
16600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16601 if (!SWIG_IsOK(ecode2)) {
16602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16603 }
16604 arg2 = static_cast< bool >(val2);
16605 }
16606 {
16607 PyThreadState* __tstate = wxPyBeginAllowThreads();
16608 result = (arg1)->Rotate90(arg2);
16609 wxPyEndAllowThreads(__tstate);
16610 if (PyErr_Occurred()) SWIG_fail;
16611 }
16612 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16613 return resultobj;
16614 fail:
16615 return NULL;
16616 }
16617
16618
16619 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16620 PyObject *resultobj = 0;
16621 wxImage *arg1 = (wxImage *) 0 ;
16622 bool arg2 = (bool) true ;
16623 SwigValueWrapper<wxImage > result;
16624 void *argp1 = 0 ;
16625 int res1 = 0 ;
16626 bool val2 ;
16627 int ecode2 = 0 ;
16628 PyObject * obj0 = 0 ;
16629 PyObject * obj1 = 0 ;
16630 char * kwnames[] = {
16631 (char *) "self",(char *) "horizontally", NULL
16632 };
16633
16634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16636 if (!SWIG_IsOK(res1)) {
16637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16638 }
16639 arg1 = reinterpret_cast< wxImage * >(argp1);
16640 if (obj1) {
16641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16642 if (!SWIG_IsOK(ecode2)) {
16643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16644 }
16645 arg2 = static_cast< bool >(val2);
16646 }
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 result = (arg1)->Mirror(arg2);
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj = 0;
16662 wxImage *arg1 = (wxImage *) 0 ;
16663 byte arg2 ;
16664 byte arg3 ;
16665 byte arg4 ;
16666 byte arg5 ;
16667 byte arg6 ;
16668 byte arg7 ;
16669 void *argp1 = 0 ;
16670 int res1 = 0 ;
16671 unsigned char val2 ;
16672 int ecode2 = 0 ;
16673 unsigned char val3 ;
16674 int ecode3 = 0 ;
16675 unsigned char val4 ;
16676 int ecode4 = 0 ;
16677 unsigned char val5 ;
16678 int ecode5 = 0 ;
16679 unsigned char val6 ;
16680 int ecode6 = 0 ;
16681 unsigned char val7 ;
16682 int ecode7 = 0 ;
16683 PyObject * obj0 = 0 ;
16684 PyObject * obj1 = 0 ;
16685 PyObject * obj2 = 0 ;
16686 PyObject * obj3 = 0 ;
16687 PyObject * obj4 = 0 ;
16688 PyObject * obj5 = 0 ;
16689 PyObject * obj6 = 0 ;
16690 char * kwnames[] = {
16691 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16692 };
16693
16694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16696 if (!SWIG_IsOK(res1)) {
16697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16698 }
16699 arg1 = reinterpret_cast< wxImage * >(argp1);
16700 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16701 if (!SWIG_IsOK(ecode2)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16703 }
16704 arg2 = static_cast< byte >(val2);
16705 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16706 if (!SWIG_IsOK(ecode3)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16708 }
16709 arg3 = static_cast< byte >(val3);
16710 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16711 if (!SWIG_IsOK(ecode4)) {
16712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16713 }
16714 arg4 = static_cast< byte >(val4);
16715 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16716 if (!SWIG_IsOK(ecode5)) {
16717 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16718 }
16719 arg5 = static_cast< byte >(val5);
16720 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16721 if (!SWIG_IsOK(ecode6)) {
16722 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16723 }
16724 arg6 = static_cast< byte >(val6);
16725 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16726 if (!SWIG_IsOK(ecode7)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16728 }
16729 arg7 = static_cast< byte >(val7);
16730 {
16731 PyThreadState* __tstate = wxPyBeginAllowThreads();
16732 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 resultobj = SWIG_Py_Void();
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj = 0;
16745 wxImage *arg1 = (wxImage *) 0 ;
16746 double arg2 = (double) 0.299 ;
16747 double arg3 = (double) 0.587 ;
16748 double arg4 = (double) 0.114 ;
16749 SwigValueWrapper<wxImage > result;
16750 void *argp1 = 0 ;
16751 int res1 = 0 ;
16752 double val2 ;
16753 int ecode2 = 0 ;
16754 double val3 ;
16755 int ecode3 = 0 ;
16756 double val4 ;
16757 int ecode4 = 0 ;
16758 PyObject * obj0 = 0 ;
16759 PyObject * obj1 = 0 ;
16760 PyObject * obj2 = 0 ;
16761 PyObject * obj3 = 0 ;
16762 char * kwnames[] = {
16763 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16764 };
16765
16766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16768 if (!SWIG_IsOK(res1)) {
16769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16770 }
16771 arg1 = reinterpret_cast< wxImage * >(argp1);
16772 if (obj1) {
16773 ecode2 = SWIG_AsVal_double(obj1, &val2);
16774 if (!SWIG_IsOK(ecode2)) {
16775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16776 }
16777 arg2 = static_cast< double >(val2);
16778 }
16779 if (obj2) {
16780 ecode3 = SWIG_AsVal_double(obj2, &val3);
16781 if (!SWIG_IsOK(ecode3)) {
16782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16783 }
16784 arg3 = static_cast< double >(val3);
16785 }
16786 if (obj3) {
16787 ecode4 = SWIG_AsVal_double(obj3, &val4);
16788 if (!SWIG_IsOK(ecode4)) {
16789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16790 }
16791 arg4 = static_cast< double >(val4);
16792 }
16793 {
16794 PyThreadState* __tstate = wxPyBeginAllowThreads();
16795 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj = 0;
16808 wxImage *arg1 = (wxImage *) 0 ;
16809 byte arg2 ;
16810 byte arg3 ;
16811 byte arg4 ;
16812 SwigValueWrapper<wxImage > result;
16813 void *argp1 = 0 ;
16814 int res1 = 0 ;
16815 unsigned char val2 ;
16816 int ecode2 = 0 ;
16817 unsigned char val3 ;
16818 int ecode3 = 0 ;
16819 unsigned char val4 ;
16820 int ecode4 = 0 ;
16821 PyObject * obj0 = 0 ;
16822 PyObject * obj1 = 0 ;
16823 PyObject * obj2 = 0 ;
16824 PyObject * obj3 = 0 ;
16825 char * kwnames[] = {
16826 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16827 };
16828
16829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16831 if (!SWIG_IsOK(res1)) {
16832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16833 }
16834 arg1 = reinterpret_cast< wxImage * >(argp1);
16835 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16836 if (!SWIG_IsOK(ecode2)) {
16837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16838 }
16839 arg2 = static_cast< byte >(val2);
16840 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16841 if (!SWIG_IsOK(ecode3)) {
16842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16843 }
16844 arg3 = static_cast< byte >(val3);
16845 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16846 if (!SWIG_IsOK(ecode4)) {
16847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16848 }
16849 arg4 = static_cast< byte >(val4);
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16853 wxPyEndAllowThreads(__tstate);
16854 if (PyErr_Occurred()) SWIG_fail;
16855 }
16856 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16857 return resultobj;
16858 fail:
16859 return NULL;
16860 }
16861
16862
16863 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16864 PyObject *resultobj = 0;
16865 wxImage *arg1 = (wxImage *) 0 ;
16866 wxString *arg2 = 0 ;
16867 wxString *arg3 = 0 ;
16868 void *argp1 = 0 ;
16869 int res1 = 0 ;
16870 bool temp2 = false ;
16871 bool temp3 = false ;
16872 PyObject * obj0 = 0 ;
16873 PyObject * obj1 = 0 ;
16874 PyObject * obj2 = 0 ;
16875 char * kwnames[] = {
16876 (char *) "self",(char *) "name",(char *) "value", NULL
16877 };
16878
16879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16881 if (!SWIG_IsOK(res1)) {
16882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16883 }
16884 arg1 = reinterpret_cast< wxImage * >(argp1);
16885 {
16886 arg2 = wxString_in_helper(obj1);
16887 if (arg2 == NULL) SWIG_fail;
16888 temp2 = true;
16889 }
16890 {
16891 arg3 = wxString_in_helper(obj2);
16892 if (arg3 == NULL) SWIG_fail;
16893 temp3 = true;
16894 }
16895 {
16896 PyThreadState* __tstate = wxPyBeginAllowThreads();
16897 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 resultobj = SWIG_Py_Void();
16902 {
16903 if (temp2)
16904 delete arg2;
16905 }
16906 {
16907 if (temp3)
16908 delete arg3;
16909 }
16910 return resultobj;
16911 fail:
16912 {
16913 if (temp2)
16914 delete arg2;
16915 }
16916 {
16917 if (temp3)
16918 delete arg3;
16919 }
16920 return NULL;
16921 }
16922
16923
16924 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16925 PyObject *resultobj = 0;
16926 wxImage *arg1 = (wxImage *) 0 ;
16927 wxString *arg2 = 0 ;
16928 int arg3 ;
16929 void *argp1 = 0 ;
16930 int res1 = 0 ;
16931 bool temp2 = false ;
16932 int val3 ;
16933 int ecode3 = 0 ;
16934 PyObject * obj0 = 0 ;
16935 PyObject * obj1 = 0 ;
16936 PyObject * obj2 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "self",(char *) "name",(char *) "value", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16943 if (!SWIG_IsOK(res1)) {
16944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16945 }
16946 arg1 = reinterpret_cast< wxImage * >(argp1);
16947 {
16948 arg2 = wxString_in_helper(obj1);
16949 if (arg2 == NULL) SWIG_fail;
16950 temp2 = true;
16951 }
16952 ecode3 = SWIG_AsVal_int(obj2, &val3);
16953 if (!SWIG_IsOK(ecode3)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16955 }
16956 arg3 = static_cast< int >(val3);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 (arg1)->SetOption((wxString const &)*arg2,arg3);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 resultobj = SWIG_Py_Void();
16964 {
16965 if (temp2)
16966 delete arg2;
16967 }
16968 return resultobj;
16969 fail:
16970 {
16971 if (temp2)
16972 delete arg2;
16973 }
16974 return NULL;
16975 }
16976
16977
16978 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16979 PyObject *resultobj = 0;
16980 wxImage *arg1 = (wxImage *) 0 ;
16981 wxString *arg2 = 0 ;
16982 wxString result;
16983 void *argp1 = 0 ;
16984 int res1 = 0 ;
16985 bool temp2 = false ;
16986 PyObject * obj0 = 0 ;
16987 PyObject * obj1 = 0 ;
16988 char * kwnames[] = {
16989 (char *) "self",(char *) "name", NULL
16990 };
16991
16992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16994 if (!SWIG_IsOK(res1)) {
16995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16996 }
16997 arg1 = reinterpret_cast< wxImage * >(argp1);
16998 {
16999 arg2 = wxString_in_helper(obj1);
17000 if (arg2 == NULL) SWIG_fail;
17001 temp2 = true;
17002 }
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 #if wxUSE_UNICODE
17011 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17012 #else
17013 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17014 #endif
17015 }
17016 {
17017 if (temp2)
17018 delete arg2;
17019 }
17020 return resultobj;
17021 fail:
17022 {
17023 if (temp2)
17024 delete arg2;
17025 }
17026 return NULL;
17027 }
17028
17029
17030 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17031 PyObject *resultobj = 0;
17032 wxImage *arg1 = (wxImage *) 0 ;
17033 wxString *arg2 = 0 ;
17034 int result;
17035 void *argp1 = 0 ;
17036 int res1 = 0 ;
17037 bool temp2 = false ;
17038 PyObject * obj0 = 0 ;
17039 PyObject * obj1 = 0 ;
17040 char * kwnames[] = {
17041 (char *) "self",(char *) "name", NULL
17042 };
17043
17044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17046 if (!SWIG_IsOK(res1)) {
17047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17048 }
17049 arg1 = reinterpret_cast< wxImage * >(argp1);
17050 {
17051 arg2 = wxString_in_helper(obj1);
17052 if (arg2 == NULL) SWIG_fail;
17053 temp2 = true;
17054 }
17055 {
17056 PyThreadState* __tstate = wxPyBeginAllowThreads();
17057 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17058 wxPyEndAllowThreads(__tstate);
17059 if (PyErr_Occurred()) SWIG_fail;
17060 }
17061 resultobj = SWIG_From_int(static_cast< int >(result));
17062 {
17063 if (temp2)
17064 delete arg2;
17065 }
17066 return resultobj;
17067 fail:
17068 {
17069 if (temp2)
17070 delete arg2;
17071 }
17072 return NULL;
17073 }
17074
17075
17076 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17077 PyObject *resultobj = 0;
17078 wxImage *arg1 = (wxImage *) 0 ;
17079 wxString *arg2 = 0 ;
17080 bool result;
17081 void *argp1 = 0 ;
17082 int res1 = 0 ;
17083 bool temp2 = false ;
17084 PyObject * obj0 = 0 ;
17085 PyObject * obj1 = 0 ;
17086 char * kwnames[] = {
17087 (char *) "self",(char *) "name", NULL
17088 };
17089
17090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17092 if (!SWIG_IsOK(res1)) {
17093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17094 }
17095 arg1 = reinterpret_cast< wxImage * >(argp1);
17096 {
17097 arg2 = wxString_in_helper(obj1);
17098 if (arg2 == NULL) SWIG_fail;
17099 temp2 = true;
17100 }
17101 {
17102 PyThreadState* __tstate = wxPyBeginAllowThreads();
17103 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17104 wxPyEndAllowThreads(__tstate);
17105 if (PyErr_Occurred()) SWIG_fail;
17106 }
17107 {
17108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17109 }
17110 {
17111 if (temp2)
17112 delete arg2;
17113 }
17114 return resultobj;
17115 fail:
17116 {
17117 if (temp2)
17118 delete arg2;
17119 }
17120 return NULL;
17121 }
17122
17123
17124 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17125 PyObject *resultobj = 0;
17126 wxImage *arg1 = (wxImage *) 0 ;
17127 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17128 unsigned long result;
17129 void *argp1 = 0 ;
17130 int res1 = 0 ;
17131 unsigned long val2 ;
17132 int ecode2 = 0 ;
17133 PyObject * obj0 = 0 ;
17134 PyObject * obj1 = 0 ;
17135 char * kwnames[] = {
17136 (char *) "self",(char *) "stopafter", NULL
17137 };
17138
17139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17141 if (!SWIG_IsOK(res1)) {
17142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17143 }
17144 arg1 = reinterpret_cast< wxImage * >(argp1);
17145 if (obj1) {
17146 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17147 if (!SWIG_IsOK(ecode2)) {
17148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17149 }
17150 arg2 = static_cast< unsigned long >(val2);
17151 }
17152 {
17153 PyThreadState* __tstate = wxPyBeginAllowThreads();
17154 result = (unsigned long)(arg1)->CountColours(arg2);
17155 wxPyEndAllowThreads(__tstate);
17156 if (PyErr_Occurred()) SWIG_fail;
17157 }
17158 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17159 return resultobj;
17160 fail:
17161 return NULL;
17162 }
17163
17164
17165 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj = 0;
17167 wxImage *arg1 = (wxImage *) 0 ;
17168 wxImageHistogram *arg2 = 0 ;
17169 unsigned long result;
17170 void *argp1 = 0 ;
17171 int res1 = 0 ;
17172 void *argp2 = 0 ;
17173 int res2 = 0 ;
17174 PyObject * obj0 = 0 ;
17175 PyObject * obj1 = 0 ;
17176 char * kwnames[] = {
17177 (char *) "self",(char *) "h", NULL
17178 };
17179
17180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17182 if (!SWIG_IsOK(res1)) {
17183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17184 }
17185 arg1 = reinterpret_cast< wxImage * >(argp1);
17186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17187 if (!SWIG_IsOK(res2)) {
17188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17189 }
17190 if (!argp2) {
17191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17192 }
17193 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17197 wxPyEndAllowThreads(__tstate);
17198 if (PyErr_Occurred()) SWIG_fail;
17199 }
17200 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17201 return resultobj;
17202 fail:
17203 return NULL;
17204 }
17205
17206
17207 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17208 PyObject *resultobj = 0;
17209 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17210 void *argp1 = 0 ;
17211 int res1 = 0 ;
17212 PyObject * obj0 = 0 ;
17213 char * kwnames[] = {
17214 (char *) "handler", NULL
17215 };
17216
17217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17219 if (!SWIG_IsOK(res1)) {
17220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17221 }
17222 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17223 {
17224 PyThreadState* __tstate = wxPyBeginAllowThreads();
17225 wxImage::AddHandler(arg1);
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 resultobj = SWIG_Py_Void();
17230 return resultobj;
17231 fail:
17232 return NULL;
17233 }
17234
17235
17236 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17237 PyObject *resultobj = 0;
17238 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17239 void *argp1 = 0 ;
17240 int res1 = 0 ;
17241 PyObject * obj0 = 0 ;
17242 char * kwnames[] = {
17243 (char *) "handler", NULL
17244 };
17245
17246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17248 if (!SWIG_IsOK(res1)) {
17249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17250 }
17251 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 wxImage::InsertHandler(arg1);
17255 wxPyEndAllowThreads(__tstate);
17256 if (PyErr_Occurred()) SWIG_fail;
17257 }
17258 resultobj = SWIG_Py_Void();
17259 return resultobj;
17260 fail:
17261 return NULL;
17262 }
17263
17264
17265 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17266 PyObject *resultobj = 0;
17267 wxString *arg1 = 0 ;
17268 bool result;
17269 bool temp1 = false ;
17270 PyObject * obj0 = 0 ;
17271 char * kwnames[] = {
17272 (char *) "name", NULL
17273 };
17274
17275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17276 {
17277 arg1 = wxString_in_helper(obj0);
17278 if (arg1 == NULL) SWIG_fail;
17279 temp1 = true;
17280 }
17281 {
17282 PyThreadState* __tstate = wxPyBeginAllowThreads();
17283 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17284 wxPyEndAllowThreads(__tstate);
17285 if (PyErr_Occurred()) SWIG_fail;
17286 }
17287 {
17288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17289 }
17290 {
17291 if (temp1)
17292 delete arg1;
17293 }
17294 return resultobj;
17295 fail:
17296 {
17297 if (temp1)
17298 delete arg1;
17299 }
17300 return NULL;
17301 }
17302
17303
17304 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17305 PyObject *resultobj = 0;
17306 PyObject *result = 0 ;
17307
17308 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17309 {
17310 PyThreadState* __tstate = wxPyBeginAllowThreads();
17311 result = (PyObject *)wxImage_GetHandlers();
17312 wxPyEndAllowThreads(__tstate);
17313 if (PyErr_Occurred()) SWIG_fail;
17314 }
17315 resultobj = result;
17316 return resultobj;
17317 fail:
17318 return NULL;
17319 }
17320
17321
17322 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *resultobj = 0;
17324 wxString result;
17325
17326 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = wxImage::GetImageExtWildcard();
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 {
17334 #if wxUSE_UNICODE
17335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17336 #else
17337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17338 #endif
17339 }
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj = 0;
17348 wxImage *arg1 = (wxImage *) 0 ;
17349 int arg2 = (int) -1 ;
17350 wxBitmap result;
17351 void *argp1 = 0 ;
17352 int res1 = 0 ;
17353 int val2 ;
17354 int ecode2 = 0 ;
17355 PyObject * obj0 = 0 ;
17356 PyObject * obj1 = 0 ;
17357 char * kwnames[] = {
17358 (char *) "self",(char *) "depth", NULL
17359 };
17360
17361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17363 if (!SWIG_IsOK(res1)) {
17364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17365 }
17366 arg1 = reinterpret_cast< wxImage * >(argp1);
17367 if (obj1) {
17368 ecode2 = SWIG_AsVal_int(obj1, &val2);
17369 if (!SWIG_IsOK(ecode2)) {
17370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17371 }
17372 arg2 = static_cast< int >(val2);
17373 }
17374 {
17375 if (!wxPyCheckForApp()) SWIG_fail;
17376 PyThreadState* __tstate = wxPyBeginAllowThreads();
17377 result = wxImage_ConvertToBitmap(arg1,arg2);
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17382 return resultobj;
17383 fail:
17384 return NULL;
17385 }
17386
17387
17388 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17389 PyObject *resultobj = 0;
17390 wxImage *arg1 = (wxImage *) 0 ;
17391 byte arg2 ;
17392 byte arg3 ;
17393 byte arg4 ;
17394 wxBitmap result;
17395 void *argp1 = 0 ;
17396 int res1 = 0 ;
17397 unsigned char val2 ;
17398 int ecode2 = 0 ;
17399 unsigned char val3 ;
17400 int ecode3 = 0 ;
17401 unsigned char val4 ;
17402 int ecode4 = 0 ;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 PyObject * obj2 = 0 ;
17406 PyObject * obj3 = 0 ;
17407 char * kwnames[] = {
17408 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17409 };
17410
17411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17413 if (!SWIG_IsOK(res1)) {
17414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17415 }
17416 arg1 = reinterpret_cast< wxImage * >(argp1);
17417 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17418 if (!SWIG_IsOK(ecode2)) {
17419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17420 }
17421 arg2 = static_cast< byte >(val2);
17422 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17423 if (!SWIG_IsOK(ecode3)) {
17424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17425 }
17426 arg3 = static_cast< byte >(val3);
17427 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17428 if (!SWIG_IsOK(ecode4)) {
17429 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17430 }
17431 arg4 = static_cast< byte >(val4);
17432 {
17433 if (!wxPyCheckForApp()) SWIG_fail;
17434 PyThreadState* __tstate = wxPyBeginAllowThreads();
17435 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17436 wxPyEndAllowThreads(__tstate);
17437 if (PyErr_Occurred()) SWIG_fail;
17438 }
17439 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17440 return resultobj;
17441 fail:
17442 return NULL;
17443 }
17444
17445
17446 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17447 PyObject *resultobj = 0;
17448 wxImage *arg1 = (wxImage *) 0 ;
17449 double arg2 ;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 double val2 ;
17453 int ecode2 = 0 ;
17454 PyObject * obj0 = 0 ;
17455 PyObject * obj1 = 0 ;
17456 char * kwnames[] = {
17457 (char *) "self",(char *) "angle", NULL
17458 };
17459
17460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17462 if (!SWIG_IsOK(res1)) {
17463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17464 }
17465 arg1 = reinterpret_cast< wxImage * >(argp1);
17466 ecode2 = SWIG_AsVal_double(obj1, &val2);
17467 if (!SWIG_IsOK(ecode2)) {
17468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17469 }
17470 arg2 = static_cast< double >(val2);
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 (arg1)->RotateHue(arg2);
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 resultobj = SWIG_Py_Void();
17478 return resultobj;
17479 fail:
17480 return NULL;
17481 }
17482
17483
17484 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17485 PyObject *resultobj = 0;
17486 wxImage_RGBValue arg1 ;
17487 wxImage_HSVValue result;
17488 void *argp1 ;
17489 int res1 = 0 ;
17490 PyObject * obj0 = 0 ;
17491 char * kwnames[] = {
17492 (char *) "rgb", NULL
17493 };
17494
17495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17496 {
17497 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17498 if (!SWIG_IsOK(res1)) {
17499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17500 }
17501 if (!argp1) {
17502 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17503 } else {
17504 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17505 arg1 = *temp;
17506 if (SWIG_IsNewObj(res1)) delete temp;
17507 }
17508 }
17509 {
17510 PyThreadState* __tstate = wxPyBeginAllowThreads();
17511 result = wxImage::RGBtoHSV(arg1);
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17516 return resultobj;
17517 fail:
17518 return NULL;
17519 }
17520
17521
17522 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17523 PyObject *resultobj = 0;
17524 wxImage_HSVValue arg1 ;
17525 wxImage_RGBValue result;
17526 void *argp1 ;
17527 int res1 = 0 ;
17528 PyObject * obj0 = 0 ;
17529 char * kwnames[] = {
17530 (char *) "hsv", NULL
17531 };
17532
17533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17534 {
17535 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17536 if (!SWIG_IsOK(res1)) {
17537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17538 }
17539 if (!argp1) {
17540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17541 } else {
17542 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17543 arg1 = *temp;
17544 if (SWIG_IsNewObj(res1)) delete temp;
17545 }
17546 }
17547 {
17548 PyThreadState* __tstate = wxPyBeginAllowThreads();
17549 result = wxImage::HSVtoRGB(arg1);
17550 wxPyEndAllowThreads(__tstate);
17551 if (PyErr_Occurred()) SWIG_fail;
17552 }
17553 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17554 return resultobj;
17555 fail:
17556 return NULL;
17557 }
17558
17559
17560 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17561 PyObject *obj;
17562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17563 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17564 return SWIG_Py_Void();
17565 }
17566
17567 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17568 return SWIG_Python_InitShadowInstance(args);
17569 }
17570
17571 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17572 PyObject *resultobj = 0;
17573 int arg1 ;
17574 int arg2 ;
17575 buffer arg3 ;
17576 int arg4 ;
17577 buffer arg5 = (buffer) NULL ;
17578 int arg6 = (int) 0 ;
17579 wxImage *result = 0 ;
17580 int val1 ;
17581 int ecode1 = 0 ;
17582 int val2 ;
17583 int ecode2 = 0 ;
17584 Py_ssize_t temp3 ;
17585 Py_ssize_t temp5 ;
17586 PyObject * obj0 = 0 ;
17587 PyObject * obj1 = 0 ;
17588 PyObject * obj2 = 0 ;
17589 PyObject * obj3 = 0 ;
17590 char * kwnames[] = {
17591 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17592 };
17593
17594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17595 ecode1 = SWIG_AsVal_int(obj0, &val1);
17596 if (!SWIG_IsOK(ecode1)) {
17597 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17598 }
17599 arg1 = static_cast< int >(val1);
17600 ecode2 = SWIG_AsVal_int(obj1, &val2);
17601 if (!SWIG_IsOK(ecode2)) {
17602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17603 }
17604 arg2 = static_cast< int >(val2);
17605 {
17606 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17607 arg4 = (int)temp3;
17608 }
17609 if (obj3) {
17610 {
17611 if (obj3 != Py_None) {
17612 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17613 arg6 = (int)temp5;
17614 }
17615 }
17616 }
17617 {
17618 PyThreadState* __tstate = wxPyBeginAllowThreads();
17619 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17620 wxPyEndAllowThreads(__tstate);
17621 if (PyErr_Occurred()) SWIG_fail;
17622 }
17623 {
17624 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17625 }
17626 return resultobj;
17627 fail:
17628 return NULL;
17629 }
17630
17631
17632 SWIGINTERN int NullImage_set(PyObject *) {
17633 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17634 return 1;
17635 }
17636
17637
17638 SWIGINTERN PyObject *NullImage_get(void) {
17639 PyObject *pyobj = 0;
17640
17641 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17642 return pyobj;
17643 }
17644
17645
17646 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17647 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17648 return 1;
17649 }
17650
17651
17652 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17653 PyObject *pyobj = 0;
17654
17655 {
17656 #if wxUSE_UNICODE
17657 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17658 #else
17659 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17660 #endif
17661 }
17662 return pyobj;
17663 }
17664
17665
17666 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17667 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17668 return 1;
17669 }
17670
17671
17672 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17673 PyObject *pyobj = 0;
17674
17675 {
17676 #if wxUSE_UNICODE
17677 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17678 #else
17679 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17680 #endif
17681 }
17682 return pyobj;
17683 }
17684
17685
17686 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17687 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17688 return 1;
17689 }
17690
17691
17692 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17693 PyObject *pyobj = 0;
17694
17695 {
17696 #if wxUSE_UNICODE
17697 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17698 #else
17699 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17700 #endif
17701 }
17702 return pyobj;
17703 }
17704
17705
17706 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17707 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17708 return 1;
17709 }
17710
17711
17712 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17713 PyObject *pyobj = 0;
17714
17715 {
17716 #if wxUSE_UNICODE
17717 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17718 #else
17719 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17720 #endif
17721 }
17722 return pyobj;
17723 }
17724
17725
17726 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17727 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17728 return 1;
17729 }
17730
17731
17732 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17733 PyObject *pyobj = 0;
17734
17735 {
17736 #if wxUSE_UNICODE
17737 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17738 #else
17739 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17740 #endif
17741 }
17742 return pyobj;
17743 }
17744
17745
17746 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17747 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17748 return 1;
17749 }
17750
17751
17752 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17753 PyObject *pyobj = 0;
17754
17755 {
17756 #if wxUSE_UNICODE
17757 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17758 #else
17759 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17760 #endif
17761 }
17762 return pyobj;
17763 }
17764
17765
17766 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17767 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17768 return 1;
17769 }
17770
17771
17772 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17773 PyObject *pyobj = 0;
17774
17775 {
17776 #if wxUSE_UNICODE
17777 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17778 #else
17779 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17780 #endif
17781 }
17782 return pyobj;
17783 }
17784
17785
17786 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17787 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17788 return 1;
17789 }
17790
17791
17792 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17793 PyObject *pyobj = 0;
17794
17795 {
17796 #if wxUSE_UNICODE
17797 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17798 #else
17799 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17800 #endif
17801 }
17802 return pyobj;
17803 }
17804
17805
17806 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17807 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17808 return 1;
17809 }
17810
17811
17812 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17813 PyObject *pyobj = 0;
17814
17815 {
17816 #if wxUSE_UNICODE
17817 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17818 #else
17819 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17820 #endif
17821 }
17822 return pyobj;
17823 }
17824
17825
17826 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17827 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17828 return 1;
17829 }
17830
17831
17832 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17833 PyObject *pyobj = 0;
17834
17835 {
17836 #if wxUSE_UNICODE
17837 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17838 #else
17839 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17840 #endif
17841 }
17842 return pyobj;
17843 }
17844
17845
17846 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17847 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17848 return 1;
17849 }
17850
17851
17852 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17853 PyObject *pyobj = 0;
17854
17855 {
17856 #if wxUSE_UNICODE
17857 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17858 #else
17859 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17860 #endif
17861 }
17862 return pyobj;
17863 }
17864
17865
17866 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17867 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17868 return 1;
17869 }
17870
17871
17872 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17873 PyObject *pyobj = 0;
17874
17875 {
17876 #if wxUSE_UNICODE
17877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17878 #else
17879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17880 #endif
17881 }
17882 return pyobj;
17883 }
17884
17885
17886 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17887 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17888 return 1;
17889 }
17890
17891
17892 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17893 PyObject *pyobj = 0;
17894
17895 {
17896 #if wxUSE_UNICODE
17897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17898 #else
17899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17900 #endif
17901 }
17902 return pyobj;
17903 }
17904
17905
17906 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17907 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17908 return 1;
17909 }
17910
17911
17912 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17913 PyObject *pyobj = 0;
17914
17915 {
17916 #if wxUSE_UNICODE
17917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17918 #else
17919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17920 #endif
17921 }
17922 return pyobj;
17923 }
17924
17925
17926 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17928 return 1;
17929 }
17930
17931
17932 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17933 PyObject *pyobj = 0;
17934
17935 {
17936 #if wxUSE_UNICODE
17937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17938 #else
17939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17940 #endif
17941 }
17942 return pyobj;
17943 }
17944
17945
17946 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17947 PyObject *resultobj = 0;
17948 wxBMPHandler *result = 0 ;
17949
17950 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17951 {
17952 PyThreadState* __tstate = wxPyBeginAllowThreads();
17953 result = (wxBMPHandler *)new wxBMPHandler();
17954 wxPyEndAllowThreads(__tstate);
17955 if (PyErr_Occurred()) SWIG_fail;
17956 }
17957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17965 PyObject *obj;
17966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17967 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17968 return SWIG_Py_Void();
17969 }
17970
17971 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17972 return SWIG_Python_InitShadowInstance(args);
17973 }
17974
17975 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *resultobj = 0;
17977 wxICOHandler *result = 0 ;
17978
17979 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17980 {
17981 PyThreadState* __tstate = wxPyBeginAllowThreads();
17982 result = (wxICOHandler *)new wxICOHandler();
17983 wxPyEndAllowThreads(__tstate);
17984 if (PyErr_Occurred()) SWIG_fail;
17985 }
17986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17994 PyObject *obj;
17995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17996 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17997 return SWIG_Py_Void();
17998 }
17999
18000 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18001 return SWIG_Python_InitShadowInstance(args);
18002 }
18003
18004 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18005 PyObject *resultobj = 0;
18006 wxCURHandler *result = 0 ;
18007
18008 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 result = (wxCURHandler *)new wxCURHandler();
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18023 PyObject *obj;
18024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18025 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18026 return SWIG_Py_Void();
18027 }
18028
18029 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18030 return SWIG_Python_InitShadowInstance(args);
18031 }
18032
18033 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18034 PyObject *resultobj = 0;
18035 wxANIHandler *result = 0 ;
18036
18037 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18038 {
18039 PyThreadState* __tstate = wxPyBeginAllowThreads();
18040 result = (wxANIHandler *)new wxANIHandler();
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18045 return resultobj;
18046 fail:
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18052 PyObject *obj;
18053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18054 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18055 return SWIG_Py_Void();
18056 }
18057
18058 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18059 return SWIG_Python_InitShadowInstance(args);
18060 }
18061
18062 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18063 PyObject *resultobj = 0;
18064 wxPNGHandler *result = 0 ;
18065
18066 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18067 {
18068 PyThreadState* __tstate = wxPyBeginAllowThreads();
18069 result = (wxPNGHandler *)new wxPNGHandler();
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18081 PyObject *obj;
18082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18083 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18084 return SWIG_Py_Void();
18085 }
18086
18087 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18088 return SWIG_Python_InitShadowInstance(args);
18089 }
18090
18091 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18092 PyObject *resultobj = 0;
18093 wxGIFHandler *result = 0 ;
18094
18095 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18096 {
18097 PyThreadState* __tstate = wxPyBeginAllowThreads();
18098 result = (wxGIFHandler *)new wxGIFHandler();
18099 wxPyEndAllowThreads(__tstate);
18100 if (PyErr_Occurred()) SWIG_fail;
18101 }
18102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18103 return resultobj;
18104 fail:
18105 return NULL;
18106 }
18107
18108
18109 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18110 PyObject *obj;
18111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18112 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18113 return SWIG_Py_Void();
18114 }
18115
18116 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18117 return SWIG_Python_InitShadowInstance(args);
18118 }
18119
18120 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18121 PyObject *resultobj = 0;
18122 wxPCXHandler *result = 0 ;
18123
18124 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18125 {
18126 PyThreadState* __tstate = wxPyBeginAllowThreads();
18127 result = (wxPCXHandler *)new wxPCXHandler();
18128 wxPyEndAllowThreads(__tstate);
18129 if (PyErr_Occurred()) SWIG_fail;
18130 }
18131 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18132 return resultobj;
18133 fail:
18134 return NULL;
18135 }
18136
18137
18138 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18139 PyObject *obj;
18140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18141 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18142 return SWIG_Py_Void();
18143 }
18144
18145 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18146 return SWIG_Python_InitShadowInstance(args);
18147 }
18148
18149 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18150 PyObject *resultobj = 0;
18151 wxJPEGHandler *result = 0 ;
18152
18153 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 result = (wxJPEGHandler *)new wxJPEGHandler();
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18168 PyObject *obj;
18169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18170 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18171 return SWIG_Py_Void();
18172 }
18173
18174 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18175 return SWIG_Python_InitShadowInstance(args);
18176 }
18177
18178 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18179 PyObject *resultobj = 0;
18180 wxPNMHandler *result = 0 ;
18181
18182 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18183 {
18184 PyThreadState* __tstate = wxPyBeginAllowThreads();
18185 result = (wxPNMHandler *)new wxPNMHandler();
18186 wxPyEndAllowThreads(__tstate);
18187 if (PyErr_Occurred()) SWIG_fail;
18188 }
18189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18197 PyObject *obj;
18198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18200 return SWIG_Py_Void();
18201 }
18202
18203 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18204 return SWIG_Python_InitShadowInstance(args);
18205 }
18206
18207 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18208 PyObject *resultobj = 0;
18209 wxXPMHandler *result = 0 ;
18210
18211 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18212 {
18213 PyThreadState* __tstate = wxPyBeginAllowThreads();
18214 result = (wxXPMHandler *)new wxXPMHandler();
18215 wxPyEndAllowThreads(__tstate);
18216 if (PyErr_Occurred()) SWIG_fail;
18217 }
18218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18226 PyObject *obj;
18227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18228 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18229 return SWIG_Py_Void();
18230 }
18231
18232 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18233 return SWIG_Python_InitShadowInstance(args);
18234 }
18235
18236 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18237 PyObject *resultobj = 0;
18238 wxTIFFHandler *result = 0 ;
18239
18240 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18241 {
18242 PyThreadState* __tstate = wxPyBeginAllowThreads();
18243 result = (wxTIFFHandler *)new wxTIFFHandler();
18244 wxPyEndAllowThreads(__tstate);
18245 if (PyErr_Occurred()) SWIG_fail;
18246 }
18247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18248 return resultobj;
18249 fail:
18250 return NULL;
18251 }
18252
18253
18254 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18255 PyObject *obj;
18256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18257 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18258 return SWIG_Py_Void();
18259 }
18260
18261 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18262 return SWIG_Python_InitShadowInstance(args);
18263 }
18264
18265 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj = 0;
18267 wxImage *arg1 = 0 ;
18268 wxImage *arg2 = 0 ;
18269 int arg3 = (int) 236 ;
18270 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18271 bool result;
18272 void *argp1 = 0 ;
18273 int res1 = 0 ;
18274 void *argp2 = 0 ;
18275 int res2 = 0 ;
18276 int val3 ;
18277 int ecode3 = 0 ;
18278 int val4 ;
18279 int ecode4 = 0 ;
18280 PyObject * obj0 = 0 ;
18281 PyObject * obj1 = 0 ;
18282 PyObject * obj2 = 0 ;
18283 PyObject * obj3 = 0 ;
18284 char * kwnames[] = {
18285 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18286 };
18287
18288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18289 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18290 if (!SWIG_IsOK(res1)) {
18291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18292 }
18293 if (!argp1) {
18294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18295 }
18296 arg1 = reinterpret_cast< wxImage * >(argp1);
18297 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18298 if (!SWIG_IsOK(res2)) {
18299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18300 }
18301 if (!argp2) {
18302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18303 }
18304 arg2 = reinterpret_cast< wxImage * >(argp2);
18305 if (obj2) {
18306 ecode3 = SWIG_AsVal_int(obj2, &val3);
18307 if (!SWIG_IsOK(ecode3)) {
18308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18309 }
18310 arg3 = static_cast< int >(val3);
18311 }
18312 if (obj3) {
18313 ecode4 = SWIG_AsVal_int(obj3, &val4);
18314 if (!SWIG_IsOK(ecode4)) {
18315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18316 }
18317 arg4 = static_cast< int >(val4);
18318 }
18319 {
18320 PyThreadState* __tstate = wxPyBeginAllowThreads();
18321 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18322 wxPyEndAllowThreads(__tstate);
18323 if (PyErr_Occurred()) SWIG_fail;
18324 }
18325 {
18326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18327 }
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18335 PyObject *obj;
18336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18337 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18338 return SWIG_Py_Void();
18339 }
18340
18341 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18342 PyObject *resultobj = 0;
18343 wxEvtHandler *result = 0 ;
18344
18345 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (wxEvtHandler *)new wxEvtHandler();
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18360 PyObject *resultobj = 0;
18361 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18362 wxEvtHandler *result = 0 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 PyObject *swig_obj[1] ;
18366
18367 if (!args) SWIG_fail;
18368 swig_obj[0] = args;
18369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18370 if (!SWIG_IsOK(res1)) {
18371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18372 }
18373 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18374 {
18375 PyThreadState* __tstate = wxPyBeginAllowThreads();
18376 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18377 wxPyEndAllowThreads(__tstate);
18378 if (PyErr_Occurred()) SWIG_fail;
18379 }
18380 {
18381 resultobj = wxPyMake_wxObject(result, 0);
18382 }
18383 return resultobj;
18384 fail:
18385 return NULL;
18386 }
18387
18388
18389 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(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_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18402 }
18403 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18404 {
18405 PyThreadState* __tstate = wxPyBeginAllowThreads();
18406 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
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_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj = 0;
18421 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18422 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18423 void *argp1 = 0 ;
18424 int res1 = 0 ;
18425 void *argp2 = 0 ;
18426 int res2 = 0 ;
18427 PyObject * obj0 = 0 ;
18428 PyObject * obj1 = 0 ;
18429 char * kwnames[] = {
18430 (char *) "self",(char *) "handler", NULL
18431 };
18432
18433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18435 if (!SWIG_IsOK(res1)) {
18436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18437 }
18438 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18439 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18440 if (!SWIG_IsOK(res2)) {
18441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18442 }
18443 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18444 {
18445 PyThreadState* __tstate = wxPyBeginAllowThreads();
18446 (arg1)->SetNextHandler(arg2);
18447 wxPyEndAllowThreads(__tstate);
18448 if (PyErr_Occurred()) SWIG_fail;
18449 }
18450 resultobj = SWIG_Py_Void();
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj = 0;
18459 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18460 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18461 void *argp1 = 0 ;
18462 int res1 = 0 ;
18463 void *argp2 = 0 ;
18464 int res2 = 0 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char * kwnames[] = {
18468 (char *) "self",(char *) "handler", NULL
18469 };
18470
18471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18473 if (!SWIG_IsOK(res1)) {
18474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18475 }
18476 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18478 if (!SWIG_IsOK(res2)) {
18479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18480 }
18481 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18482 {
18483 PyThreadState* __tstate = wxPyBeginAllowThreads();
18484 (arg1)->SetPreviousHandler(arg2);
18485 wxPyEndAllowThreads(__tstate);
18486 if (PyErr_Occurred()) SWIG_fail;
18487 }
18488 resultobj = SWIG_Py_Void();
18489 return resultobj;
18490 fail:
18491 return NULL;
18492 }
18493
18494
18495 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18496 PyObject *resultobj = 0;
18497 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18498 bool result;
18499 void *argp1 = 0 ;
18500 int res1 = 0 ;
18501 PyObject *swig_obj[1] ;
18502
18503 if (!args) SWIG_fail;
18504 swig_obj[0] = args;
18505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18506 if (!SWIG_IsOK(res1)) {
18507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18508 }
18509 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18510 {
18511 PyThreadState* __tstate = wxPyBeginAllowThreads();
18512 result = (bool)(arg1)->GetEvtHandlerEnabled();
18513 wxPyEndAllowThreads(__tstate);
18514 if (PyErr_Occurred()) SWIG_fail;
18515 }
18516 {
18517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18518 }
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj = 0;
18527 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18528 bool arg2 ;
18529 void *argp1 = 0 ;
18530 int res1 = 0 ;
18531 bool val2 ;
18532 int ecode2 = 0 ;
18533 PyObject * obj0 = 0 ;
18534 PyObject * obj1 = 0 ;
18535 char * kwnames[] = {
18536 (char *) "self",(char *) "enabled", NULL
18537 };
18538
18539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18541 if (!SWIG_IsOK(res1)) {
18542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18543 }
18544 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18545 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18546 if (!SWIG_IsOK(ecode2)) {
18547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18548 }
18549 arg2 = static_cast< bool >(val2);
18550 {
18551 PyThreadState* __tstate = wxPyBeginAllowThreads();
18552 (arg1)->SetEvtHandlerEnabled(arg2);
18553 wxPyEndAllowThreads(__tstate);
18554 if (PyErr_Occurred()) SWIG_fail;
18555 }
18556 resultobj = SWIG_Py_Void();
18557 return resultobj;
18558 fail:
18559 return NULL;
18560 }
18561
18562
18563 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18564 PyObject *resultobj = 0;
18565 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18566 wxEvent *arg2 = 0 ;
18567 bool result;
18568 void *argp1 = 0 ;
18569 int res1 = 0 ;
18570 void *argp2 = 0 ;
18571 int res2 = 0 ;
18572 PyObject * obj0 = 0 ;
18573 PyObject * obj1 = 0 ;
18574 char * kwnames[] = {
18575 (char *) "self",(char *) "event", NULL
18576 };
18577
18578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18580 if (!SWIG_IsOK(res1)) {
18581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18582 }
18583 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18584 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18585 if (!SWIG_IsOK(res2)) {
18586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18587 }
18588 if (!argp2) {
18589 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18590 }
18591 arg2 = reinterpret_cast< wxEvent * >(argp2);
18592 {
18593 PyThreadState* __tstate = wxPyBeginAllowThreads();
18594 result = (bool)(arg1)->ProcessEvent(*arg2);
18595 wxPyEndAllowThreads(__tstate);
18596 if (PyErr_Occurred()) SWIG_fail;
18597 }
18598 {
18599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18600 }
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = 0;
18609 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18610 wxEvent *arg2 = 0 ;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 void *argp2 = 0 ;
18614 int res2 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "self",(char *) "event", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18625 }
18626 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18628 if (!SWIG_IsOK(res2)) {
18629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18630 }
18631 if (!argp2) {
18632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18633 }
18634 arg2 = reinterpret_cast< wxEvent * >(argp2);
18635 {
18636 PyThreadState* __tstate = wxPyBeginAllowThreads();
18637 (arg1)->AddPendingEvent(*arg2);
18638 wxPyEndAllowThreads(__tstate);
18639 if (PyErr_Occurred()) SWIG_fail;
18640 }
18641 resultobj = SWIG_Py_Void();
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18649 PyObject *resultobj = 0;
18650 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18651 void *argp1 = 0 ;
18652 int res1 = 0 ;
18653 PyObject *swig_obj[1] ;
18654
18655 if (!args) SWIG_fail;
18656 swig_obj[0] = args;
18657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18658 if (!SWIG_IsOK(res1)) {
18659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18660 }
18661 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 (arg1)->ProcessPendingEvents();
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 resultobj = SWIG_Py_Void();
18669 return resultobj;
18670 fail:
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18676 PyObject *resultobj = 0;
18677 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18678 int arg2 ;
18679 int arg3 ;
18680 int arg4 ;
18681 PyObject *arg5 = (PyObject *) 0 ;
18682 void *argp1 = 0 ;
18683 int res1 = 0 ;
18684 int val2 ;
18685 int ecode2 = 0 ;
18686 int val3 ;
18687 int ecode3 = 0 ;
18688 int val4 ;
18689 int ecode4 = 0 ;
18690 PyObject * obj0 = 0 ;
18691 PyObject * obj1 = 0 ;
18692 PyObject * obj2 = 0 ;
18693 PyObject * obj3 = 0 ;
18694 PyObject * obj4 = 0 ;
18695 char * kwnames[] = {
18696 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18697 };
18698
18699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18701 if (!SWIG_IsOK(res1)) {
18702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18703 }
18704 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18705 ecode2 = SWIG_AsVal_int(obj1, &val2);
18706 if (!SWIG_IsOK(ecode2)) {
18707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18708 }
18709 arg2 = static_cast< int >(val2);
18710 ecode3 = SWIG_AsVal_int(obj2, &val3);
18711 if (!SWIG_IsOK(ecode3)) {
18712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18713 }
18714 arg3 = static_cast< int >(val3);
18715 ecode4 = SWIG_AsVal_int(obj3, &val4);
18716 if (!SWIG_IsOK(ecode4)) {
18717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18718 }
18719 arg4 = static_cast< int >(val4);
18720 arg5 = obj4;
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 resultobj = SWIG_Py_Void();
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18735 PyObject *resultobj = 0;
18736 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18737 int arg2 ;
18738 int arg3 = (int) -1 ;
18739 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18740 bool result;
18741 void *argp1 = 0 ;
18742 int res1 = 0 ;
18743 int val2 ;
18744 int ecode2 = 0 ;
18745 int val3 ;
18746 int ecode3 = 0 ;
18747 int val4 ;
18748 int ecode4 = 0 ;
18749 PyObject * obj0 = 0 ;
18750 PyObject * obj1 = 0 ;
18751 PyObject * obj2 = 0 ;
18752 PyObject * obj3 = 0 ;
18753 char * kwnames[] = {
18754 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18755 };
18756
18757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18759 if (!SWIG_IsOK(res1)) {
18760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18761 }
18762 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18763 ecode2 = SWIG_AsVal_int(obj1, &val2);
18764 if (!SWIG_IsOK(ecode2)) {
18765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18766 }
18767 arg2 = static_cast< int >(val2);
18768 if (obj2) {
18769 ecode3 = SWIG_AsVal_int(obj2, &val3);
18770 if (!SWIG_IsOK(ecode3)) {
18771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18772 }
18773 arg3 = static_cast< int >(val3);
18774 }
18775 if (obj3) {
18776 ecode4 = SWIG_AsVal_int(obj3, &val4);
18777 if (!SWIG_IsOK(ecode4)) {
18778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18779 }
18780 arg4 = static_cast< wxEventType >(val4);
18781 }
18782 {
18783 PyThreadState* __tstate = wxPyBeginAllowThreads();
18784 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18785 wxPyEndAllowThreads(__tstate);
18786 if (PyErr_Occurred()) SWIG_fail;
18787 }
18788 {
18789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18790 }
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj = 0;
18799 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18800 PyObject *arg2 = (PyObject *) 0 ;
18801 bool arg3 = (bool) true ;
18802 void *argp1 = 0 ;
18803 int res1 = 0 ;
18804 bool val3 ;
18805 int ecode3 = 0 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 PyObject * obj2 = 0 ;
18809 char * kwnames[] = {
18810 (char *) "self",(char *) "_self",(char *) "incref", NULL
18811 };
18812
18813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18815 if (!SWIG_IsOK(res1)) {
18816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18817 }
18818 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18819 arg2 = obj1;
18820 if (obj2) {
18821 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18822 if (!SWIG_IsOK(ecode3)) {
18823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18824 }
18825 arg3 = static_cast< bool >(val3);
18826 }
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18830 wxPyEndAllowThreads(__tstate);
18831 if (PyErr_Occurred()) SWIG_fail;
18832 }
18833 resultobj = SWIG_Py_Void();
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18841 PyObject *obj;
18842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18843 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18844 return SWIG_Py_Void();
18845 }
18846
18847 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18848 return SWIG_Python_InitShadowInstance(args);
18849 }
18850
18851 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18852 PyObject *resultobj = 0;
18853 wxEventType result;
18854
18855 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 result = (wxEventType)wxNewEventType();
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 resultobj = SWIG_From_int(static_cast< int >(result));
18863 return resultobj;
18864 fail:
18865 return NULL;
18866 }
18867
18868
18869 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18870 PyObject *resultobj = 0;
18871 wxEvent *arg1 = (wxEvent *) 0 ;
18872 void *argp1 = 0 ;
18873 int res1 = 0 ;
18874 PyObject *swig_obj[1] ;
18875
18876 if (!args) SWIG_fail;
18877 swig_obj[0] = args;
18878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18881 }
18882 arg1 = reinterpret_cast< wxEvent * >(argp1);
18883 {
18884 PyThreadState* __tstate = wxPyBeginAllowThreads();
18885 delete arg1;
18886
18887 wxPyEndAllowThreads(__tstate);
18888 if (PyErr_Occurred()) SWIG_fail;
18889 }
18890 resultobj = SWIG_Py_Void();
18891 return resultobj;
18892 fail:
18893 return NULL;
18894 }
18895
18896
18897 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18898 PyObject *resultobj = 0;
18899 wxEvent *arg1 = (wxEvent *) 0 ;
18900 wxEventType arg2 ;
18901 void *argp1 = 0 ;
18902 int res1 = 0 ;
18903 int val2 ;
18904 int ecode2 = 0 ;
18905 PyObject * obj0 = 0 ;
18906 PyObject * obj1 = 0 ;
18907 char * kwnames[] = {
18908 (char *) "self",(char *) "typ", NULL
18909 };
18910
18911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18913 if (!SWIG_IsOK(res1)) {
18914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18915 }
18916 arg1 = reinterpret_cast< wxEvent * >(argp1);
18917 ecode2 = SWIG_AsVal_int(obj1, &val2);
18918 if (!SWIG_IsOK(ecode2)) {
18919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18920 }
18921 arg2 = static_cast< wxEventType >(val2);
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 (arg1)->SetEventType(arg2);
18925 wxPyEndAllowThreads(__tstate);
18926 if (PyErr_Occurred()) SWIG_fail;
18927 }
18928 resultobj = SWIG_Py_Void();
18929 return resultobj;
18930 fail:
18931 return NULL;
18932 }
18933
18934
18935 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18936 PyObject *resultobj = 0;
18937 wxEvent *arg1 = (wxEvent *) 0 ;
18938 wxEventType result;
18939 void *argp1 = 0 ;
18940 int res1 = 0 ;
18941 PyObject *swig_obj[1] ;
18942
18943 if (!args) SWIG_fail;
18944 swig_obj[0] = args;
18945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18946 if (!SWIG_IsOK(res1)) {
18947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18948 }
18949 arg1 = reinterpret_cast< wxEvent * >(argp1);
18950 {
18951 PyThreadState* __tstate = wxPyBeginAllowThreads();
18952 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18953 wxPyEndAllowThreads(__tstate);
18954 if (PyErr_Occurred()) SWIG_fail;
18955 }
18956 resultobj = SWIG_From_int(static_cast< int >(result));
18957 return resultobj;
18958 fail:
18959 return NULL;
18960 }
18961
18962
18963 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18964 PyObject *resultobj = 0;
18965 wxEvent *arg1 = (wxEvent *) 0 ;
18966 wxObject *result = 0 ;
18967 void *argp1 = 0 ;
18968 int res1 = 0 ;
18969 PyObject *swig_obj[1] ;
18970
18971 if (!args) SWIG_fail;
18972 swig_obj[0] = args;
18973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18974 if (!SWIG_IsOK(res1)) {
18975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18976 }
18977 arg1 = reinterpret_cast< wxEvent * >(argp1);
18978 {
18979 PyThreadState* __tstate = wxPyBeginAllowThreads();
18980 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18981 wxPyEndAllowThreads(__tstate);
18982 if (PyErr_Occurred()) SWIG_fail;
18983 }
18984 {
18985 resultobj = wxPyMake_wxObject(result, (bool)0);
18986 }
18987 return resultobj;
18988 fail:
18989 return NULL;
18990 }
18991
18992
18993 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18994 PyObject *resultobj = 0;
18995 wxEvent *arg1 = (wxEvent *) 0 ;
18996 wxObject *arg2 = (wxObject *) 0 ;
18997 void *argp1 = 0 ;
18998 int res1 = 0 ;
18999 void *argp2 = 0 ;
19000 int res2 = 0 ;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 char * kwnames[] = {
19004 (char *) "self",(char *) "obj", NULL
19005 };
19006
19007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19009 if (!SWIG_IsOK(res1)) {
19010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19011 }
19012 arg1 = reinterpret_cast< wxEvent * >(argp1);
19013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19014 if (!SWIG_IsOK(res2)) {
19015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19016 }
19017 arg2 = reinterpret_cast< wxObject * >(argp2);
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 (arg1)->SetEventObject(arg2);
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 resultobj = SWIG_Py_Void();
19025 return resultobj;
19026 fail:
19027 return NULL;
19028 }
19029
19030
19031 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19032 PyObject *resultobj = 0;
19033 wxEvent *arg1 = (wxEvent *) 0 ;
19034 long result;
19035 void *argp1 = 0 ;
19036 int res1 = 0 ;
19037 PyObject *swig_obj[1] ;
19038
19039 if (!args) SWIG_fail;
19040 swig_obj[0] = args;
19041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19042 if (!SWIG_IsOK(res1)) {
19043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19044 }
19045 arg1 = reinterpret_cast< wxEvent * >(argp1);
19046 {
19047 PyThreadState* __tstate = wxPyBeginAllowThreads();
19048 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 resultobj = SWIG_From_long(static_cast< long >(result));
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj = 0;
19061 wxEvent *arg1 = (wxEvent *) 0 ;
19062 long arg2 = (long) 0 ;
19063 void *argp1 = 0 ;
19064 int res1 = 0 ;
19065 long val2 ;
19066 int ecode2 = 0 ;
19067 PyObject * obj0 = 0 ;
19068 PyObject * obj1 = 0 ;
19069 char * kwnames[] = {
19070 (char *) "self",(char *) "ts", NULL
19071 };
19072
19073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19075 if (!SWIG_IsOK(res1)) {
19076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19077 }
19078 arg1 = reinterpret_cast< wxEvent * >(argp1);
19079 if (obj1) {
19080 ecode2 = SWIG_AsVal_long(obj1, &val2);
19081 if (!SWIG_IsOK(ecode2)) {
19082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19083 }
19084 arg2 = static_cast< long >(val2);
19085 }
19086 {
19087 PyThreadState* __tstate = wxPyBeginAllowThreads();
19088 (arg1)->SetTimestamp(arg2);
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 resultobj = SWIG_Py_Void();
19093 return resultobj;
19094 fail:
19095 return NULL;
19096 }
19097
19098
19099 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19100 PyObject *resultobj = 0;
19101 wxEvent *arg1 = (wxEvent *) 0 ;
19102 int result;
19103 void *argp1 = 0 ;
19104 int res1 = 0 ;
19105 PyObject *swig_obj[1] ;
19106
19107 if (!args) SWIG_fail;
19108 swig_obj[0] = args;
19109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19112 }
19113 arg1 = reinterpret_cast< wxEvent * >(argp1);
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 result = (int)((wxEvent const *)arg1)->GetId();
19117 wxPyEndAllowThreads(__tstate);
19118 if (PyErr_Occurred()) SWIG_fail;
19119 }
19120 resultobj = SWIG_From_int(static_cast< int >(result));
19121 return resultobj;
19122 fail:
19123 return NULL;
19124 }
19125
19126
19127 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19128 PyObject *resultobj = 0;
19129 wxEvent *arg1 = (wxEvent *) 0 ;
19130 int arg2 ;
19131 void *argp1 = 0 ;
19132 int res1 = 0 ;
19133 int val2 ;
19134 int ecode2 = 0 ;
19135 PyObject * obj0 = 0 ;
19136 PyObject * obj1 = 0 ;
19137 char * kwnames[] = {
19138 (char *) "self",(char *) "Id", NULL
19139 };
19140
19141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19143 if (!SWIG_IsOK(res1)) {
19144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19145 }
19146 arg1 = reinterpret_cast< wxEvent * >(argp1);
19147 ecode2 = SWIG_AsVal_int(obj1, &val2);
19148 if (!SWIG_IsOK(ecode2)) {
19149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19150 }
19151 arg2 = static_cast< int >(val2);
19152 {
19153 PyThreadState* __tstate = wxPyBeginAllowThreads();
19154 (arg1)->SetId(arg2);
19155 wxPyEndAllowThreads(__tstate);
19156 if (PyErr_Occurred()) SWIG_fail;
19157 }
19158 resultobj = SWIG_Py_Void();
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19166 PyObject *resultobj = 0;
19167 wxEvent *arg1 = (wxEvent *) 0 ;
19168 bool result;
19169 void *argp1 = 0 ;
19170 int res1 = 0 ;
19171 PyObject *swig_obj[1] ;
19172
19173 if (!args) SWIG_fail;
19174 swig_obj[0] = args;
19175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19176 if (!SWIG_IsOK(res1)) {
19177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19178 }
19179 arg1 = reinterpret_cast< wxEvent * >(argp1);
19180 {
19181 PyThreadState* __tstate = wxPyBeginAllowThreads();
19182 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19183 wxPyEndAllowThreads(__tstate);
19184 if (PyErr_Occurred()) SWIG_fail;
19185 }
19186 {
19187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19188 }
19189 return resultobj;
19190 fail:
19191 return NULL;
19192 }
19193
19194
19195 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj = 0;
19197 wxEvent *arg1 = (wxEvent *) 0 ;
19198 bool arg2 = (bool) true ;
19199 void *argp1 = 0 ;
19200 int res1 = 0 ;
19201 bool val2 ;
19202 int ecode2 = 0 ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char * kwnames[] = {
19206 (char *) "self",(char *) "skip", NULL
19207 };
19208
19209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19213 }
19214 arg1 = reinterpret_cast< wxEvent * >(argp1);
19215 if (obj1) {
19216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19217 if (!SWIG_IsOK(ecode2)) {
19218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19219 }
19220 arg2 = static_cast< bool >(val2);
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 (arg1)->Skip(arg2);
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 resultobj = SWIG_Py_Void();
19229 return resultobj;
19230 fail:
19231 return NULL;
19232 }
19233
19234
19235 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19236 PyObject *resultobj = 0;
19237 wxEvent *arg1 = (wxEvent *) 0 ;
19238 bool result;
19239 void *argp1 = 0 ;
19240 int res1 = 0 ;
19241 PyObject *swig_obj[1] ;
19242
19243 if (!args) SWIG_fail;
19244 swig_obj[0] = args;
19245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19246 if (!SWIG_IsOK(res1)) {
19247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19248 }
19249 arg1 = reinterpret_cast< wxEvent * >(argp1);
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19253 wxPyEndAllowThreads(__tstate);
19254 if (PyErr_Occurred()) SWIG_fail;
19255 }
19256 {
19257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19258 }
19259 return resultobj;
19260 fail:
19261 return NULL;
19262 }
19263
19264
19265 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19266 PyObject *resultobj = 0;
19267 wxEvent *arg1 = (wxEvent *) 0 ;
19268 bool result;
19269 void *argp1 = 0 ;
19270 int res1 = 0 ;
19271 PyObject *swig_obj[1] ;
19272
19273 if (!args) SWIG_fail;
19274 swig_obj[0] = args;
19275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19276 if (!SWIG_IsOK(res1)) {
19277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19278 }
19279 arg1 = reinterpret_cast< wxEvent * >(argp1);
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19283 wxPyEndAllowThreads(__tstate);
19284 if (PyErr_Occurred()) SWIG_fail;
19285 }
19286 {
19287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19288 }
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19296 PyObject *resultobj = 0;
19297 wxEvent *arg1 = (wxEvent *) 0 ;
19298 int 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_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19308 }
19309 arg1 = reinterpret_cast< wxEvent * >(argp1);
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = (int)(arg1)->StopPropagation();
19313 wxPyEndAllowThreads(__tstate);
19314 if (PyErr_Occurred()) SWIG_fail;
19315 }
19316 resultobj = SWIG_From_int(static_cast< int >(result));
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19324 PyObject *resultobj = 0;
19325 wxEvent *arg1 = (wxEvent *) 0 ;
19326 int arg2 ;
19327 void *argp1 = 0 ;
19328 int res1 = 0 ;
19329 int val2 ;
19330 int ecode2 = 0 ;
19331 PyObject * obj0 = 0 ;
19332 PyObject * obj1 = 0 ;
19333 char * kwnames[] = {
19334 (char *) "self",(char *) "propagationLevel", NULL
19335 };
19336
19337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19339 if (!SWIG_IsOK(res1)) {
19340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19341 }
19342 arg1 = reinterpret_cast< wxEvent * >(argp1);
19343 ecode2 = SWIG_AsVal_int(obj1, &val2);
19344 if (!SWIG_IsOK(ecode2)) {
19345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19346 }
19347 arg2 = static_cast< int >(val2);
19348 {
19349 PyThreadState* __tstate = wxPyBeginAllowThreads();
19350 (arg1)->ResumePropagation(arg2);
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 resultobj = SWIG_Py_Void();
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19362 PyObject *resultobj = 0;
19363 wxEvent *arg1 = (wxEvent *) 0 ;
19364 wxEvent *result = 0 ;
19365 void *argp1 = 0 ;
19366 int res1 = 0 ;
19367 PyObject *swig_obj[1] ;
19368
19369 if (!args) SWIG_fail;
19370 swig_obj[0] = args;
19371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19372 if (!SWIG_IsOK(res1)) {
19373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19374 }
19375 arg1 = reinterpret_cast< wxEvent * >(argp1);
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (wxEvent *)(arg1)->Clone();
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19390 PyObject *obj;
19391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19392 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19393 return SWIG_Py_Void();
19394 }
19395
19396 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19397 PyObject *resultobj = 0;
19398 wxEvent *arg1 = 0 ;
19399 wxPropagationDisabler *result = 0 ;
19400 void *argp1 = 0 ;
19401 int res1 = 0 ;
19402 PyObject * obj0 = 0 ;
19403 char * kwnames[] = {
19404 (char *) "event", NULL
19405 };
19406
19407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19408 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19409 if (!SWIG_IsOK(res1)) {
19410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19411 }
19412 if (!argp1) {
19413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19414 }
19415 arg1 = reinterpret_cast< wxEvent * >(argp1);
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19430 PyObject *resultobj = 0;
19431 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19432 void *argp1 = 0 ;
19433 int res1 = 0 ;
19434 PyObject *swig_obj[1] ;
19435
19436 if (!args) SWIG_fail;
19437 swig_obj[0] = args;
19438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19439 if (!SWIG_IsOK(res1)) {
19440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19441 }
19442 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19443 {
19444 PyThreadState* __tstate = wxPyBeginAllowThreads();
19445 delete arg1;
19446
19447 wxPyEndAllowThreads(__tstate);
19448 if (PyErr_Occurred()) SWIG_fail;
19449 }
19450 resultobj = SWIG_Py_Void();
19451 return resultobj;
19452 fail:
19453 return NULL;
19454 }
19455
19456
19457 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19458 PyObject *obj;
19459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19460 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19461 return SWIG_Py_Void();
19462 }
19463
19464 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19465 return SWIG_Python_InitShadowInstance(args);
19466 }
19467
19468 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19469 PyObject *resultobj = 0;
19470 wxEvent *arg1 = 0 ;
19471 wxPropagateOnce *result = 0 ;
19472 void *argp1 = 0 ;
19473 int res1 = 0 ;
19474 PyObject * obj0 = 0 ;
19475 char * kwnames[] = {
19476 (char *) "event", NULL
19477 };
19478
19479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19480 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19481 if (!SWIG_IsOK(res1)) {
19482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19483 }
19484 if (!argp1) {
19485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19486 }
19487 arg1 = reinterpret_cast< wxEvent * >(argp1);
19488 {
19489 PyThreadState* __tstate = wxPyBeginAllowThreads();
19490 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19491 wxPyEndAllowThreads(__tstate);
19492 if (PyErr_Occurred()) SWIG_fail;
19493 }
19494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19502 PyObject *resultobj = 0;
19503 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19504 void *argp1 = 0 ;
19505 int res1 = 0 ;
19506 PyObject *swig_obj[1] ;
19507
19508 if (!args) SWIG_fail;
19509 swig_obj[0] = args;
19510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19511 if (!SWIG_IsOK(res1)) {
19512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19513 }
19514 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19515 {
19516 PyThreadState* __tstate = wxPyBeginAllowThreads();
19517 delete arg1;
19518
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 resultobj = SWIG_Py_Void();
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19530 PyObject *obj;
19531 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19532 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19533 return SWIG_Py_Void();
19534 }
19535
19536 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19537 return SWIG_Python_InitShadowInstance(args);
19538 }
19539
19540 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19541 PyObject *resultobj = 0;
19542 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19543 int arg2 = (int) 0 ;
19544 wxCommandEvent *result = 0 ;
19545 int val1 ;
19546 int ecode1 = 0 ;
19547 int val2 ;
19548 int ecode2 = 0 ;
19549 PyObject * obj0 = 0 ;
19550 PyObject * obj1 = 0 ;
19551 char * kwnames[] = {
19552 (char *) "commandType",(char *) "winid", NULL
19553 };
19554
19555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19556 if (obj0) {
19557 ecode1 = SWIG_AsVal_int(obj0, &val1);
19558 if (!SWIG_IsOK(ecode1)) {
19559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19560 }
19561 arg1 = static_cast< wxEventType >(val1);
19562 }
19563 if (obj1) {
19564 ecode2 = SWIG_AsVal_int(obj1, &val2);
19565 if (!SWIG_IsOK(ecode2)) {
19566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19567 }
19568 arg2 = static_cast< int >(val2);
19569 }
19570 {
19571 PyThreadState* __tstate = wxPyBeginAllowThreads();
19572 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19573 wxPyEndAllowThreads(__tstate);
19574 if (PyErr_Occurred()) SWIG_fail;
19575 }
19576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19577 return resultobj;
19578 fail:
19579 return NULL;
19580 }
19581
19582
19583 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19584 PyObject *resultobj = 0;
19585 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19586 int result;
19587 void *argp1 = 0 ;
19588 int res1 = 0 ;
19589 PyObject *swig_obj[1] ;
19590
19591 if (!args) SWIG_fail;
19592 swig_obj[0] = args;
19593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19594 if (!SWIG_IsOK(res1)) {
19595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19596 }
19597 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19598 {
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_From_int(static_cast< int >(result));
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19612 PyObject *resultobj = 0;
19613 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19614 wxString *arg2 = 0 ;
19615 void *argp1 = 0 ;
19616 int res1 = 0 ;
19617 bool temp2 = false ;
19618 PyObject * obj0 = 0 ;
19619 PyObject * obj1 = 0 ;
19620 char * kwnames[] = {
19621 (char *) "self",(char *) "s", NULL
19622 };
19623
19624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19628 }
19629 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19630 {
19631 arg2 = wxString_in_helper(obj1);
19632 if (arg2 == NULL) SWIG_fail;
19633 temp2 = true;
19634 }
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 (arg1)->SetString((wxString const &)*arg2);
19638 wxPyEndAllowThreads(__tstate);
19639 if (PyErr_Occurred()) SWIG_fail;
19640 }
19641 resultobj = SWIG_Py_Void();
19642 {
19643 if (temp2)
19644 delete arg2;
19645 }
19646 return resultobj;
19647 fail:
19648 {
19649 if (temp2)
19650 delete arg2;
19651 }
19652 return NULL;
19653 }
19654
19655
19656 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19657 PyObject *resultobj = 0;
19658 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19659 wxString result;
19660 void *argp1 = 0 ;
19661 int res1 = 0 ;
19662 PyObject *swig_obj[1] ;
19663
19664 if (!args) SWIG_fail;
19665 swig_obj[0] = args;
19666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19667 if (!SWIG_IsOK(res1)) {
19668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19669 }
19670 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19671 {
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 result = ((wxCommandEvent const *)arg1)->GetString();
19674 wxPyEndAllowThreads(__tstate);
19675 if (PyErr_Occurred()) SWIG_fail;
19676 }
19677 {
19678 #if wxUSE_UNICODE
19679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19680 #else
19681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19682 #endif
19683 }
19684 return resultobj;
19685 fail:
19686 return NULL;
19687 }
19688
19689
19690 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19691 PyObject *resultobj = 0;
19692 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19693 bool result;
19694 void *argp1 = 0 ;
19695 int res1 = 0 ;
19696 PyObject *swig_obj[1] ;
19697
19698 if (!args) SWIG_fail;
19699 swig_obj[0] = args;
19700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19701 if (!SWIG_IsOK(res1)) {
19702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19703 }
19704 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19705 {
19706 PyThreadState* __tstate = wxPyBeginAllowThreads();
19707 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19708 wxPyEndAllowThreads(__tstate);
19709 if (PyErr_Occurred()) SWIG_fail;
19710 }
19711 {
19712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19713 }
19714 return resultobj;
19715 fail:
19716 return NULL;
19717 }
19718
19719
19720 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19721 PyObject *resultobj = 0;
19722 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19723 bool result;
19724 void *argp1 = 0 ;
19725 int res1 = 0 ;
19726 PyObject *swig_obj[1] ;
19727
19728 if (!args) SWIG_fail;
19729 swig_obj[0] = args;
19730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19731 if (!SWIG_IsOK(res1)) {
19732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19733 }
19734 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19735 {
19736 PyThreadState* __tstate = wxPyBeginAllowThreads();
19737 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 {
19742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19743 }
19744 return resultobj;
19745 fail:
19746 return NULL;
19747 }
19748
19749
19750 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19751 PyObject *resultobj = 0;
19752 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19753 long arg2 ;
19754 void *argp1 = 0 ;
19755 int res1 = 0 ;
19756 long val2 ;
19757 int ecode2 = 0 ;
19758 PyObject * obj0 = 0 ;
19759 PyObject * obj1 = 0 ;
19760 char * kwnames[] = {
19761 (char *) "self",(char *) "extraLong", NULL
19762 };
19763
19764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19766 if (!SWIG_IsOK(res1)) {
19767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19768 }
19769 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19770 ecode2 = SWIG_AsVal_long(obj1, &val2);
19771 if (!SWIG_IsOK(ecode2)) {
19772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19773 }
19774 arg2 = static_cast< long >(val2);
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 (arg1)->SetExtraLong(arg2);
19778 wxPyEndAllowThreads(__tstate);
19779 if (PyErr_Occurred()) SWIG_fail;
19780 }
19781 resultobj = SWIG_Py_Void();
19782 return resultobj;
19783 fail:
19784 return NULL;
19785 }
19786
19787
19788 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19789 PyObject *resultobj = 0;
19790 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19791 long result;
19792 void *argp1 = 0 ;
19793 int res1 = 0 ;
19794 PyObject *swig_obj[1] ;
19795
19796 if (!args) SWIG_fail;
19797 swig_obj[0] = args;
19798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19799 if (!SWIG_IsOK(res1)) {
19800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19801 }
19802 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19803 {
19804 PyThreadState* __tstate = wxPyBeginAllowThreads();
19805 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19806 wxPyEndAllowThreads(__tstate);
19807 if (PyErr_Occurred()) SWIG_fail;
19808 }
19809 resultobj = SWIG_From_long(static_cast< long >(result));
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj = 0;
19818 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19819 int arg2 ;
19820 void *argp1 = 0 ;
19821 int res1 = 0 ;
19822 int val2 ;
19823 int ecode2 = 0 ;
19824 PyObject * obj0 = 0 ;
19825 PyObject * obj1 = 0 ;
19826 char * kwnames[] = {
19827 (char *) "self",(char *) "i", NULL
19828 };
19829
19830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19832 if (!SWIG_IsOK(res1)) {
19833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19834 }
19835 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19836 ecode2 = SWIG_AsVal_int(obj1, &val2);
19837 if (!SWIG_IsOK(ecode2)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19839 }
19840 arg2 = static_cast< int >(val2);
19841 {
19842 PyThreadState* __tstate = wxPyBeginAllowThreads();
19843 (arg1)->SetInt(arg2);
19844 wxPyEndAllowThreads(__tstate);
19845 if (PyErr_Occurred()) SWIG_fail;
19846 }
19847 resultobj = SWIG_Py_Void();
19848 return resultobj;
19849 fail:
19850 return NULL;
19851 }
19852
19853
19854 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19855 PyObject *resultobj = 0;
19856 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19857 int result;
19858 void *argp1 = 0 ;
19859 int res1 = 0 ;
19860 PyObject *swig_obj[1] ;
19861
19862 if (!args) SWIG_fail;
19863 swig_obj[0] = args;
19864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19865 if (!SWIG_IsOK(res1)) {
19866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19867 }
19868 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19872 wxPyEndAllowThreads(__tstate);
19873 if (PyErr_Occurred()) SWIG_fail;
19874 }
19875 resultobj = SWIG_From_int(static_cast< int >(result));
19876 return resultobj;
19877 fail:
19878 return NULL;
19879 }
19880
19881
19882 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19883 PyObject *resultobj = 0;
19884 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19885 PyObject *result = 0 ;
19886 void *argp1 = 0 ;
19887 int res1 = 0 ;
19888 PyObject *swig_obj[1] ;
19889
19890 if (!args) SWIG_fail;
19891 swig_obj[0] = args;
19892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19893 if (!SWIG_IsOK(res1)) {
19894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19895 }
19896 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19897 {
19898 PyThreadState* __tstate = wxPyBeginAllowThreads();
19899 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 resultobj = result;
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19911 PyObject *resultobj = 0;
19912 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19913 PyObject *arg2 = (PyObject *) 0 ;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 PyObject * obj0 = 0 ;
19917 PyObject * obj1 = 0 ;
19918 char * kwnames[] = {
19919 (char *) "self",(char *) "clientData", NULL
19920 };
19921
19922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19924 if (!SWIG_IsOK(res1)) {
19925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19926 }
19927 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19928 arg2 = obj1;
19929 {
19930 PyThreadState* __tstate = wxPyBeginAllowThreads();
19931 wxCommandEvent_SetClientData(arg1,arg2);
19932 wxPyEndAllowThreads(__tstate);
19933 if (PyErr_Occurred()) SWIG_fail;
19934 }
19935 resultobj = SWIG_Py_Void();
19936 return resultobj;
19937 fail:
19938 return NULL;
19939 }
19940
19941
19942 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19943 PyObject *resultobj = 0;
19944 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19945 wxEvent *result = 0 ;
19946 void *argp1 = 0 ;
19947 int res1 = 0 ;
19948 PyObject *swig_obj[1] ;
19949
19950 if (!args) SWIG_fail;
19951 swig_obj[0] = args;
19952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19953 if (!SWIG_IsOK(res1)) {
19954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19955 }
19956 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19960 wxPyEndAllowThreads(__tstate);
19961 if (PyErr_Occurred()) SWIG_fail;
19962 }
19963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19971 PyObject *obj;
19972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19973 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19974 return SWIG_Py_Void();
19975 }
19976
19977 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19978 return SWIG_Python_InitShadowInstance(args);
19979 }
19980
19981 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19982 PyObject *resultobj = 0;
19983 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19984 int arg2 = (int) 0 ;
19985 wxNotifyEvent *result = 0 ;
19986 int val1 ;
19987 int ecode1 = 0 ;
19988 int val2 ;
19989 int ecode2 = 0 ;
19990 PyObject * obj0 = 0 ;
19991 PyObject * obj1 = 0 ;
19992 char * kwnames[] = {
19993 (char *) "commandType",(char *) "winid", NULL
19994 };
19995
19996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19997 if (obj0) {
19998 ecode1 = SWIG_AsVal_int(obj0, &val1);
19999 if (!SWIG_IsOK(ecode1)) {
20000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20001 }
20002 arg1 = static_cast< wxEventType >(val1);
20003 }
20004 if (obj1) {
20005 ecode2 = SWIG_AsVal_int(obj1, &val2);
20006 if (!SWIG_IsOK(ecode2)) {
20007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20008 }
20009 arg2 = static_cast< int >(val2);
20010 }
20011 {
20012 PyThreadState* __tstate = wxPyBeginAllowThreads();
20013 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20014 wxPyEndAllowThreads(__tstate);
20015 if (PyErr_Occurred()) SWIG_fail;
20016 }
20017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20018 return resultobj;
20019 fail:
20020 return NULL;
20021 }
20022
20023
20024 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20025 PyObject *resultobj = 0;
20026 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20027 void *argp1 = 0 ;
20028 int res1 = 0 ;
20029 PyObject *swig_obj[1] ;
20030
20031 if (!args) SWIG_fail;
20032 swig_obj[0] = args;
20033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20034 if (!SWIG_IsOK(res1)) {
20035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20036 }
20037 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 (arg1)->Veto();
20041 wxPyEndAllowThreads(__tstate);
20042 if (PyErr_Occurred()) SWIG_fail;
20043 }
20044 resultobj = SWIG_Py_Void();
20045 return resultobj;
20046 fail:
20047 return NULL;
20048 }
20049
20050
20051 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20052 PyObject *resultobj = 0;
20053 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20054 void *argp1 = 0 ;
20055 int res1 = 0 ;
20056 PyObject *swig_obj[1] ;
20057
20058 if (!args) SWIG_fail;
20059 swig_obj[0] = args;
20060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20061 if (!SWIG_IsOK(res1)) {
20062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20063 }
20064 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20065 {
20066 PyThreadState* __tstate = wxPyBeginAllowThreads();
20067 (arg1)->Allow();
20068 wxPyEndAllowThreads(__tstate);
20069 if (PyErr_Occurred()) SWIG_fail;
20070 }
20071 resultobj = SWIG_Py_Void();
20072 return resultobj;
20073 fail:
20074 return NULL;
20075 }
20076
20077
20078 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20079 PyObject *resultobj = 0;
20080 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20081 bool result;
20082 void *argp1 = 0 ;
20083 int res1 = 0 ;
20084 PyObject *swig_obj[1] ;
20085
20086 if (!args) SWIG_fail;
20087 swig_obj[0] = args;
20088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20089 if (!SWIG_IsOK(res1)) {
20090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20091 }
20092 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20093 {
20094 PyThreadState* __tstate = wxPyBeginAllowThreads();
20095 result = (bool)(arg1)->IsAllowed();
20096 wxPyEndAllowThreads(__tstate);
20097 if (PyErr_Occurred()) SWIG_fail;
20098 }
20099 {
20100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20101 }
20102 return resultobj;
20103 fail:
20104 return NULL;
20105 }
20106
20107
20108 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20109 PyObject *obj;
20110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20111 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20112 return SWIG_Py_Void();
20113 }
20114
20115 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20116 return SWIG_Python_InitShadowInstance(args);
20117 }
20118
20119 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20120 PyObject *resultobj = 0;
20121 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20122 int arg2 = (int) 0 ;
20123 int arg3 = (int) 0 ;
20124 int arg4 = (int) 0 ;
20125 wxScrollEvent *result = 0 ;
20126 int val1 ;
20127 int ecode1 = 0 ;
20128 int val2 ;
20129 int ecode2 = 0 ;
20130 int val3 ;
20131 int ecode3 = 0 ;
20132 int val4 ;
20133 int ecode4 = 0 ;
20134 PyObject * obj0 = 0 ;
20135 PyObject * obj1 = 0 ;
20136 PyObject * obj2 = 0 ;
20137 PyObject * obj3 = 0 ;
20138 char * kwnames[] = {
20139 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20140 };
20141
20142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20143 if (obj0) {
20144 ecode1 = SWIG_AsVal_int(obj0, &val1);
20145 if (!SWIG_IsOK(ecode1)) {
20146 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20147 }
20148 arg1 = static_cast< wxEventType >(val1);
20149 }
20150 if (obj1) {
20151 ecode2 = SWIG_AsVal_int(obj1, &val2);
20152 if (!SWIG_IsOK(ecode2)) {
20153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20154 }
20155 arg2 = static_cast< int >(val2);
20156 }
20157 if (obj2) {
20158 ecode3 = SWIG_AsVal_int(obj2, &val3);
20159 if (!SWIG_IsOK(ecode3)) {
20160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20161 }
20162 arg3 = static_cast< int >(val3);
20163 }
20164 if (obj3) {
20165 ecode4 = SWIG_AsVal_int(obj3, &val4);
20166 if (!SWIG_IsOK(ecode4)) {
20167 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20168 }
20169 arg4 = static_cast< int >(val4);
20170 }
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20185 PyObject *resultobj = 0;
20186 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20187 int result;
20188 void *argp1 = 0 ;
20189 int res1 = 0 ;
20190 PyObject *swig_obj[1] ;
20191
20192 if (!args) SWIG_fail;
20193 swig_obj[0] = args;
20194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20195 if (!SWIG_IsOK(res1)) {
20196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20197 }
20198 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20199 {
20200 PyThreadState* __tstate = wxPyBeginAllowThreads();
20201 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 resultobj = SWIG_From_int(static_cast< int >(result));
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20215 int result;
20216 void *argp1 = 0 ;
20217 int res1 = 0 ;
20218 PyObject *swig_obj[1] ;
20219
20220 if (!args) SWIG_fail;
20221 swig_obj[0] = args;
20222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20223 if (!SWIG_IsOK(res1)) {
20224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20225 }
20226 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 resultobj = SWIG_From_int(static_cast< int >(result));
20234 return resultobj;
20235 fail:
20236 return NULL;
20237 }
20238
20239
20240 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20241 PyObject *resultobj = 0;
20242 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20243 int arg2 ;
20244 void *argp1 = 0 ;
20245 int res1 = 0 ;
20246 int val2 ;
20247 int ecode2 = 0 ;
20248 PyObject * obj0 = 0 ;
20249 PyObject * obj1 = 0 ;
20250 char * kwnames[] = {
20251 (char *) "self",(char *) "orient", NULL
20252 };
20253
20254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20256 if (!SWIG_IsOK(res1)) {
20257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20258 }
20259 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20260 ecode2 = SWIG_AsVal_int(obj1, &val2);
20261 if (!SWIG_IsOK(ecode2)) {
20262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20263 }
20264 arg2 = static_cast< int >(val2);
20265 {
20266 PyThreadState* __tstate = wxPyBeginAllowThreads();
20267 (arg1)->SetOrientation(arg2);
20268 wxPyEndAllowThreads(__tstate);
20269 if (PyErr_Occurred()) SWIG_fail;
20270 }
20271 resultobj = SWIG_Py_Void();
20272 return resultobj;
20273 fail:
20274 return NULL;
20275 }
20276
20277
20278 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20279 PyObject *resultobj = 0;
20280 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20281 int arg2 ;
20282 void *argp1 = 0 ;
20283 int res1 = 0 ;
20284 int val2 ;
20285 int ecode2 = 0 ;
20286 PyObject * obj0 = 0 ;
20287 PyObject * obj1 = 0 ;
20288 char * kwnames[] = {
20289 (char *) "self",(char *) "pos", NULL
20290 };
20291
20292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20294 if (!SWIG_IsOK(res1)) {
20295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20296 }
20297 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20298 ecode2 = SWIG_AsVal_int(obj1, &val2);
20299 if (!SWIG_IsOK(ecode2)) {
20300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20301 }
20302 arg2 = static_cast< int >(val2);
20303 {
20304 PyThreadState* __tstate = wxPyBeginAllowThreads();
20305 (arg1)->SetPosition(arg2);
20306 wxPyEndAllowThreads(__tstate);
20307 if (PyErr_Occurred()) SWIG_fail;
20308 }
20309 resultobj = SWIG_Py_Void();
20310 return resultobj;
20311 fail:
20312 return NULL;
20313 }
20314
20315
20316 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *obj;
20318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20319 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20320 return SWIG_Py_Void();
20321 }
20322
20323 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20324 return SWIG_Python_InitShadowInstance(args);
20325 }
20326
20327 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20328 PyObject *resultobj = 0;
20329 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20330 int arg2 = (int) 0 ;
20331 int arg3 = (int) 0 ;
20332 wxScrollWinEvent *result = 0 ;
20333 int val1 ;
20334 int ecode1 = 0 ;
20335 int val2 ;
20336 int ecode2 = 0 ;
20337 int val3 ;
20338 int ecode3 = 0 ;
20339 PyObject * obj0 = 0 ;
20340 PyObject * obj1 = 0 ;
20341 PyObject * obj2 = 0 ;
20342 char * kwnames[] = {
20343 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20344 };
20345
20346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20347 if (obj0) {
20348 ecode1 = SWIG_AsVal_int(obj0, &val1);
20349 if (!SWIG_IsOK(ecode1)) {
20350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20351 }
20352 arg1 = static_cast< wxEventType >(val1);
20353 }
20354 if (obj1) {
20355 ecode2 = SWIG_AsVal_int(obj1, &val2);
20356 if (!SWIG_IsOK(ecode2)) {
20357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20358 }
20359 arg2 = static_cast< int >(val2);
20360 }
20361 if (obj2) {
20362 ecode3 = SWIG_AsVal_int(obj2, &val3);
20363 if (!SWIG_IsOK(ecode3)) {
20364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20365 }
20366 arg3 = static_cast< int >(val3);
20367 }
20368 {
20369 PyThreadState* __tstate = wxPyBeginAllowThreads();
20370 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20371 wxPyEndAllowThreads(__tstate);
20372 if (PyErr_Occurred()) SWIG_fail;
20373 }
20374 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20375 return resultobj;
20376 fail:
20377 return NULL;
20378 }
20379
20380
20381 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20382 PyObject *resultobj = 0;
20383 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20384 int result;
20385 void *argp1 = 0 ;
20386 int res1 = 0 ;
20387 PyObject *swig_obj[1] ;
20388
20389 if (!args) SWIG_fail;
20390 swig_obj[0] = args;
20391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20392 if (!SWIG_IsOK(res1)) {
20393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20394 }
20395 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 resultobj = SWIG_From_int(static_cast< int >(result));
20403 return resultobj;
20404 fail:
20405 return NULL;
20406 }
20407
20408
20409 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20410 PyObject *resultobj = 0;
20411 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20412 int result;
20413 void *argp1 = 0 ;
20414 int res1 = 0 ;
20415 PyObject *swig_obj[1] ;
20416
20417 if (!args) SWIG_fail;
20418 swig_obj[0] = args;
20419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20420 if (!SWIG_IsOK(res1)) {
20421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20422 }
20423 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20424 {
20425 PyThreadState* __tstate = wxPyBeginAllowThreads();
20426 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20427 wxPyEndAllowThreads(__tstate);
20428 if (PyErr_Occurred()) SWIG_fail;
20429 }
20430 resultobj = SWIG_From_int(static_cast< int >(result));
20431 return resultobj;
20432 fail:
20433 return NULL;
20434 }
20435
20436
20437 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20438 PyObject *resultobj = 0;
20439 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20440 int arg2 ;
20441 void *argp1 = 0 ;
20442 int res1 = 0 ;
20443 int val2 ;
20444 int ecode2 = 0 ;
20445 PyObject * obj0 = 0 ;
20446 PyObject * obj1 = 0 ;
20447 char * kwnames[] = {
20448 (char *) "self",(char *) "orient", NULL
20449 };
20450
20451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20453 if (!SWIG_IsOK(res1)) {
20454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20455 }
20456 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20457 ecode2 = SWIG_AsVal_int(obj1, &val2);
20458 if (!SWIG_IsOK(ecode2)) {
20459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20460 }
20461 arg2 = static_cast< int >(val2);
20462 {
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 (arg1)->SetOrientation(arg2);
20465 wxPyEndAllowThreads(__tstate);
20466 if (PyErr_Occurred()) SWIG_fail;
20467 }
20468 resultobj = SWIG_Py_Void();
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20476 PyObject *resultobj = 0;
20477 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20478 int arg2 ;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 int val2 ;
20482 int ecode2 = 0 ;
20483 PyObject * obj0 = 0 ;
20484 PyObject * obj1 = 0 ;
20485 char * kwnames[] = {
20486 (char *) "self",(char *) "pos", NULL
20487 };
20488
20489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20491 if (!SWIG_IsOK(res1)) {
20492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20493 }
20494 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20495 ecode2 = SWIG_AsVal_int(obj1, &val2);
20496 if (!SWIG_IsOK(ecode2)) {
20497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20498 }
20499 arg2 = static_cast< int >(val2);
20500 {
20501 PyThreadState* __tstate = wxPyBeginAllowThreads();
20502 (arg1)->SetPosition(arg2);
20503 wxPyEndAllowThreads(__tstate);
20504 if (PyErr_Occurred()) SWIG_fail;
20505 }
20506 resultobj = SWIG_Py_Void();
20507 return resultobj;
20508 fail:
20509 return NULL;
20510 }
20511
20512
20513 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20514 PyObject *obj;
20515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20516 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20517 return SWIG_Py_Void();
20518 }
20519
20520 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20521 return SWIG_Python_InitShadowInstance(args);
20522 }
20523
20524 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20525 PyObject *resultobj = 0;
20526 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20527 wxMouseEvent *result = 0 ;
20528 int val1 ;
20529 int ecode1 = 0 ;
20530 PyObject * obj0 = 0 ;
20531 char * kwnames[] = {
20532 (char *) "mouseType", NULL
20533 };
20534
20535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20536 if (obj0) {
20537 ecode1 = SWIG_AsVal_int(obj0, &val1);
20538 if (!SWIG_IsOK(ecode1)) {
20539 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20540 }
20541 arg1 = static_cast< wxEventType >(val1);
20542 }
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 {
20550 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20551 }
20552 return resultobj;
20553 fail:
20554 return NULL;
20555 }
20556
20557
20558 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20559 PyObject *resultobj = 0;
20560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20561 bool result;
20562 void *argp1 = 0 ;
20563 int res1 = 0 ;
20564 PyObject *swig_obj[1] ;
20565
20566 if (!args) SWIG_fail;
20567 swig_obj[0] = args;
20568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20569 if (!SWIG_IsOK(res1)) {
20570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20571 }
20572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20573 {
20574 PyThreadState* __tstate = wxPyBeginAllowThreads();
20575 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20589 PyObject *resultobj = 0;
20590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20591 int arg2 = (int) wxMOUSE_BTN_ANY ;
20592 bool result;
20593 void *argp1 = 0 ;
20594 int res1 = 0 ;
20595 int val2 ;
20596 int ecode2 = 0 ;
20597 PyObject * obj0 = 0 ;
20598 PyObject * obj1 = 0 ;
20599 char * kwnames[] = {
20600 (char *) "self",(char *) "but", NULL
20601 };
20602
20603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20605 if (!SWIG_IsOK(res1)) {
20606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20607 }
20608 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20609 if (obj1) {
20610 ecode2 = SWIG_AsVal_int(obj1, &val2);
20611 if (!SWIG_IsOK(ecode2)) {
20612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20613 }
20614 arg2 = static_cast< int >(val2);
20615 }
20616 {
20617 PyThreadState* __tstate = wxPyBeginAllowThreads();
20618 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20619 wxPyEndAllowThreads(__tstate);
20620 if (PyErr_Occurred()) SWIG_fail;
20621 }
20622 {
20623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20624 }
20625 return resultobj;
20626 fail:
20627 return NULL;
20628 }
20629
20630
20631 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20632 PyObject *resultobj = 0;
20633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20634 int arg2 = (int) wxMOUSE_BTN_ANY ;
20635 bool result;
20636 void *argp1 = 0 ;
20637 int res1 = 0 ;
20638 int val2 ;
20639 int ecode2 = 0 ;
20640 PyObject * obj0 = 0 ;
20641 PyObject * obj1 = 0 ;
20642 char * kwnames[] = {
20643 (char *) "self",(char *) "but", NULL
20644 };
20645
20646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20648 if (!SWIG_IsOK(res1)) {
20649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20650 }
20651 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20652 if (obj1) {
20653 ecode2 = SWIG_AsVal_int(obj1, &val2);
20654 if (!SWIG_IsOK(ecode2)) {
20655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20656 }
20657 arg2 = static_cast< int >(val2);
20658 }
20659 {
20660 PyThreadState* __tstate = wxPyBeginAllowThreads();
20661 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20675 PyObject *resultobj = 0;
20676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20677 int arg2 = (int) wxMOUSE_BTN_ANY ;
20678 bool result;
20679 void *argp1 = 0 ;
20680 int res1 = 0 ;
20681 int val2 ;
20682 int ecode2 = 0 ;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 char * kwnames[] = {
20686 (char *) "self",(char *) "but", NULL
20687 };
20688
20689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20691 if (!SWIG_IsOK(res1)) {
20692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20693 }
20694 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20695 if (obj1) {
20696 ecode2 = SWIG_AsVal_int(obj1, &val2);
20697 if (!SWIG_IsOK(ecode2)) {
20698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20699 }
20700 arg2 = static_cast< int >(val2);
20701 }
20702 {
20703 PyThreadState* __tstate = wxPyBeginAllowThreads();
20704 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20705 wxPyEndAllowThreads(__tstate);
20706 if (PyErr_Occurred()) SWIG_fail;
20707 }
20708 {
20709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20710 }
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20718 PyObject *resultobj = 0;
20719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20720 int arg2 ;
20721 bool result;
20722 void *argp1 = 0 ;
20723 int res1 = 0 ;
20724 int val2 ;
20725 int ecode2 = 0 ;
20726 PyObject * obj0 = 0 ;
20727 PyObject * obj1 = 0 ;
20728 char * kwnames[] = {
20729 (char *) "self",(char *) "button", NULL
20730 };
20731
20732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20734 if (!SWIG_IsOK(res1)) {
20735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20736 }
20737 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20738 ecode2 = SWIG_AsVal_int(obj1, &val2);
20739 if (!SWIG_IsOK(ecode2)) {
20740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20741 }
20742 arg2 = static_cast< int >(val2);
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 {
20750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20751 }
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20759 PyObject *resultobj = 0;
20760 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20761 int arg2 ;
20762 bool result;
20763 void *argp1 = 0 ;
20764 int res1 = 0 ;
20765 int val2 ;
20766 int ecode2 = 0 ;
20767 PyObject * obj0 = 0 ;
20768 PyObject * obj1 = 0 ;
20769 char * kwnames[] = {
20770 (char *) "self",(char *) "but", NULL
20771 };
20772
20773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20775 if (!SWIG_IsOK(res1)) {
20776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20777 }
20778 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20779 ecode2 = SWIG_AsVal_int(obj1, &val2);
20780 if (!SWIG_IsOK(ecode2)) {
20781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20782 }
20783 arg2 = static_cast< int >(val2);
20784 {
20785 PyThreadState* __tstate = wxPyBeginAllowThreads();
20786 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20787 wxPyEndAllowThreads(__tstate);
20788 if (PyErr_Occurred()) SWIG_fail;
20789 }
20790 {
20791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20792 }
20793 return resultobj;
20794 fail:
20795 return NULL;
20796 }
20797
20798
20799 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20800 PyObject *resultobj = 0;
20801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20802 int result;
20803 void *argp1 = 0 ;
20804 int res1 = 0 ;
20805 PyObject *swig_obj[1] ;
20806
20807 if (!args) SWIG_fail;
20808 swig_obj[0] = args;
20809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20810 if (!SWIG_IsOK(res1)) {
20811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20812 }
20813 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20814 {
20815 PyThreadState* __tstate = wxPyBeginAllowThreads();
20816 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 resultobj = SWIG_From_int(static_cast< int >(result));
20821 return resultobj;
20822 fail:
20823 return NULL;
20824 }
20825
20826
20827 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20828 PyObject *resultobj = 0;
20829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20830 bool result;
20831 void *argp1 = 0 ;
20832 int res1 = 0 ;
20833 PyObject *swig_obj[1] ;
20834
20835 if (!args) SWIG_fail;
20836 swig_obj[0] = args;
20837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20838 if (!SWIG_IsOK(res1)) {
20839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20840 }
20841 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20842 {
20843 PyThreadState* __tstate = wxPyBeginAllowThreads();
20844 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20845 wxPyEndAllowThreads(__tstate);
20846 if (PyErr_Occurred()) SWIG_fail;
20847 }
20848 {
20849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20850 }
20851 return resultobj;
20852 fail:
20853 return NULL;
20854 }
20855
20856
20857 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20858 PyObject *resultobj = 0;
20859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20860 bool result;
20861 void *argp1 = 0 ;
20862 int res1 = 0 ;
20863 PyObject *swig_obj[1] ;
20864
20865 if (!args) SWIG_fail;
20866 swig_obj[0] = args;
20867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20868 if (!SWIG_IsOK(res1)) {
20869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20870 }
20871 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20872 {
20873 PyThreadState* __tstate = wxPyBeginAllowThreads();
20874 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20875 wxPyEndAllowThreads(__tstate);
20876 if (PyErr_Occurred()) SWIG_fail;
20877 }
20878 {
20879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20880 }
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20888 PyObject *resultobj = 0;
20889 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20890 bool result;
20891 void *argp1 = 0 ;
20892 int res1 = 0 ;
20893 PyObject *swig_obj[1] ;
20894
20895 if (!args) SWIG_fail;
20896 swig_obj[0] = args;
20897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20898 if (!SWIG_IsOK(res1)) {
20899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20900 }
20901 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20902 {
20903 PyThreadState* __tstate = wxPyBeginAllowThreads();
20904 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20905 wxPyEndAllowThreads(__tstate);
20906 if (PyErr_Occurred()) SWIG_fail;
20907 }
20908 {
20909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20910 }
20911 return resultobj;
20912 fail:
20913 return NULL;
20914 }
20915
20916
20917 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20918 PyObject *resultobj = 0;
20919 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20920 bool result;
20921 void *argp1 = 0 ;
20922 int res1 = 0 ;
20923 PyObject *swig_obj[1] ;
20924
20925 if (!args) SWIG_fail;
20926 swig_obj[0] = args;
20927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20928 if (!SWIG_IsOK(res1)) {
20929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20930 }
20931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20932 {
20933 PyThreadState* __tstate = wxPyBeginAllowThreads();
20934 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20935 wxPyEndAllowThreads(__tstate);
20936 if (PyErr_Occurred()) SWIG_fail;
20937 }
20938 {
20939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20940 }
20941 return resultobj;
20942 fail:
20943 return NULL;
20944 }
20945
20946
20947 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20948 PyObject *resultobj = 0;
20949 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20950 bool result;
20951 void *argp1 = 0 ;
20952 int res1 = 0 ;
20953 PyObject *swig_obj[1] ;
20954
20955 if (!args) SWIG_fail;
20956 swig_obj[0] = args;
20957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20958 if (!SWIG_IsOK(res1)) {
20959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20960 }
20961 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20962 {
20963 PyThreadState* __tstate = wxPyBeginAllowThreads();
20964 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20965 wxPyEndAllowThreads(__tstate);
20966 if (PyErr_Occurred()) SWIG_fail;
20967 }
20968 {
20969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20970 }
20971 return resultobj;
20972 fail:
20973 return NULL;
20974 }
20975
20976
20977 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20978 PyObject *resultobj = 0;
20979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20980 bool result;
20981 void *argp1 = 0 ;
20982 int res1 = 0 ;
20983 PyObject *swig_obj[1] ;
20984
20985 if (!args) SWIG_fail;
20986 swig_obj[0] = args;
20987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20990 }
20991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 {
20999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21000 }
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21008 PyObject *resultobj = 0;
21009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21010 bool result;
21011 void *argp1 = 0 ;
21012 int res1 = 0 ;
21013 PyObject *swig_obj[1] ;
21014
21015 if (!args) SWIG_fail;
21016 swig_obj[0] = args;
21017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21018 if (!SWIG_IsOK(res1)) {
21019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21020 }
21021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21022 {
21023 PyThreadState* __tstate = wxPyBeginAllowThreads();
21024 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21025 wxPyEndAllowThreads(__tstate);
21026 if (PyErr_Occurred()) SWIG_fail;
21027 }
21028 {
21029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21030 }
21031 return resultobj;
21032 fail:
21033 return NULL;
21034 }
21035
21036
21037 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21038 PyObject *resultobj = 0;
21039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21040 bool result;
21041 void *argp1 = 0 ;
21042 int res1 = 0 ;
21043 PyObject *swig_obj[1] ;
21044
21045 if (!args) SWIG_fail;
21046 swig_obj[0] = args;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21050 }
21051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 {
21059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21060 }
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21068 PyObject *resultobj = 0;
21069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21070 bool result;
21071 void *argp1 = 0 ;
21072 int res1 = 0 ;
21073 PyObject *swig_obj[1] ;
21074
21075 if (!args) SWIG_fail;
21076 swig_obj[0] = args;
21077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21078 if (!SWIG_IsOK(res1)) {
21079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21080 }
21081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21082 {
21083 PyThreadState* __tstate = wxPyBeginAllowThreads();
21084 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21085 wxPyEndAllowThreads(__tstate);
21086 if (PyErr_Occurred()) SWIG_fail;
21087 }
21088 {
21089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21090 }
21091 return resultobj;
21092 fail:
21093 return NULL;
21094 }
21095
21096
21097 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 PyObject *resultobj = 0;
21099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21100 bool result;
21101 void *argp1 = 0 ;
21102 int res1 = 0 ;
21103 PyObject *swig_obj[1] ;
21104
21105 if (!args) SWIG_fail;
21106 swig_obj[0] = args;
21107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21108 if (!SWIG_IsOK(res1)) {
21109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21110 }
21111 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21115 wxPyEndAllowThreads(__tstate);
21116 if (PyErr_Occurred()) SWIG_fail;
21117 }
21118 {
21119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21120 }
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21128 PyObject *resultobj = 0;
21129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21130 bool result;
21131 void *argp1 = 0 ;
21132 int res1 = 0 ;
21133 PyObject *swig_obj[1] ;
21134
21135 if (!args) SWIG_fail;
21136 swig_obj[0] = args;
21137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21138 if (!SWIG_IsOK(res1)) {
21139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21140 }
21141 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21142 {
21143 PyThreadState* __tstate = wxPyBeginAllowThreads();
21144 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21145 wxPyEndAllowThreads(__tstate);
21146 if (PyErr_Occurred()) SWIG_fail;
21147 }
21148 {
21149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21150 }
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21160 bool result;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 PyObject *swig_obj[1] ;
21164
21165 if (!args) SWIG_fail;
21166 swig_obj[0] = args;
21167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21168 if (!SWIG_IsOK(res1)) {
21169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21170 }
21171 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 {
21179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21180 }
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21188 PyObject *resultobj = 0;
21189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21190 bool result;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 PyObject *swig_obj[1] ;
21194
21195 if (!args) SWIG_fail;
21196 swig_obj[0] = args;
21197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21198 if (!SWIG_IsOK(res1)) {
21199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21200 }
21201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21205 wxPyEndAllowThreads(__tstate);
21206 if (PyErr_Occurred()) SWIG_fail;
21207 }
21208 {
21209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21210 }
21211 return resultobj;
21212 fail:
21213 return NULL;
21214 }
21215
21216
21217 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21218 PyObject *resultobj = 0;
21219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21220 bool result;
21221 void *argp1 = 0 ;
21222 int res1 = 0 ;
21223 PyObject *swig_obj[1] ;
21224
21225 if (!args) SWIG_fail;
21226 swig_obj[0] = args;
21227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21230 }
21231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 {
21239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21240 }
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21248 PyObject *resultobj = 0;
21249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21250 bool result;
21251 void *argp1 = 0 ;
21252 int res1 = 0 ;
21253 PyObject *swig_obj[1] ;
21254
21255 if (!args) SWIG_fail;
21256 swig_obj[0] = args;
21257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21258 if (!SWIG_IsOK(res1)) {
21259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21260 }
21261 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 result = (bool)(arg1)->LeftIsDown();
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 {
21269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21270 }
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21278 PyObject *resultobj = 0;
21279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21280 bool result;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 PyObject *swig_obj[1] ;
21284
21285 if (!args) SWIG_fail;
21286 swig_obj[0] = args;
21287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21290 }
21291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21292 {
21293 PyThreadState* __tstate = wxPyBeginAllowThreads();
21294 result = (bool)(arg1)->MiddleIsDown();
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 {
21299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21300 }
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308 PyObject *resultobj = 0;
21309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21310 bool result;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 PyObject *swig_obj[1] ;
21314
21315 if (!args) SWIG_fail;
21316 swig_obj[0] = args;
21317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21318 if (!SWIG_IsOK(res1)) {
21319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21320 }
21321 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21322 {
21323 PyThreadState* __tstate = wxPyBeginAllowThreads();
21324 result = (bool)(arg1)->RightIsDown();
21325 wxPyEndAllowThreads(__tstate);
21326 if (PyErr_Occurred()) SWIG_fail;
21327 }
21328 {
21329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21330 }
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21338 PyObject *resultobj = 0;
21339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21340 bool result;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 PyObject *swig_obj[1] ;
21344
21345 if (!args) SWIG_fail;
21346 swig_obj[0] = args;
21347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21348 if (!SWIG_IsOK(res1)) {
21349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21350 }
21351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21352 {
21353 PyThreadState* __tstate = wxPyBeginAllowThreads();
21354 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21355 wxPyEndAllowThreads(__tstate);
21356 if (PyErr_Occurred()) SWIG_fail;
21357 }
21358 {
21359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21360 }
21361 return resultobj;
21362 fail:
21363 return NULL;
21364 }
21365
21366
21367 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21368 PyObject *resultobj = 0;
21369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21370 bool result;
21371 void *argp1 = 0 ;
21372 int res1 = 0 ;
21373 PyObject *swig_obj[1] ;
21374
21375 if (!args) SWIG_fail;
21376 swig_obj[0] = args;
21377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21378 if (!SWIG_IsOK(res1)) {
21379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21380 }
21381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 {
21389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21398 PyObject *resultobj = 0;
21399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21400 bool result;
21401 void *argp1 = 0 ;
21402 int res1 = 0 ;
21403 PyObject *swig_obj[1] ;
21404
21405 if (!args) SWIG_fail;
21406 swig_obj[0] = args;
21407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21408 if (!SWIG_IsOK(res1)) {
21409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21410 }
21411 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21415 wxPyEndAllowThreads(__tstate);
21416 if (PyErr_Occurred()) SWIG_fail;
21417 }
21418 {
21419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21420 }
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21428 PyObject *resultobj = 0;
21429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21430 bool result;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 PyObject *swig_obj[1] ;
21434
21435 if (!args) SWIG_fail;
21436 swig_obj[0] = args;
21437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21438 if (!SWIG_IsOK(res1)) {
21439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21440 }
21441 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21442 {
21443 PyThreadState* __tstate = wxPyBeginAllowThreads();
21444 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21445 wxPyEndAllowThreads(__tstate);
21446 if (PyErr_Occurred()) SWIG_fail;
21447 }
21448 {
21449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21450 }
21451 return resultobj;
21452 fail:
21453 return NULL;
21454 }
21455
21456
21457 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21458 PyObject *resultobj = 0;
21459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21460 wxPoint result;
21461 void *argp1 = 0 ;
21462 int res1 = 0 ;
21463 PyObject *swig_obj[1] ;
21464
21465 if (!args) SWIG_fail;
21466 swig_obj[0] = args;
21467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21468 if (!SWIG_IsOK(res1)) {
21469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21470 }
21471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21472 {
21473 PyThreadState* __tstate = wxPyBeginAllowThreads();
21474 result = (arg1)->GetPosition();
21475 wxPyEndAllowThreads(__tstate);
21476 if (PyErr_Occurred()) SWIG_fail;
21477 }
21478 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21479 return resultobj;
21480 fail:
21481 return NULL;
21482 }
21483
21484
21485 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21486 PyObject *resultobj = 0;
21487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21488 long *arg2 = (long *) 0 ;
21489 long *arg3 = (long *) 0 ;
21490 void *argp1 = 0 ;
21491 int res1 = 0 ;
21492 long temp2 ;
21493 int res2 = SWIG_TMPOBJ ;
21494 long temp3 ;
21495 int res3 = SWIG_TMPOBJ ;
21496 PyObject *swig_obj[1] ;
21497
21498 arg2 = &temp2;
21499 arg3 = &temp3;
21500 if (!args) SWIG_fail;
21501 swig_obj[0] = args;
21502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21503 if (!SWIG_IsOK(res1)) {
21504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21505 }
21506 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21507 {
21508 PyThreadState* __tstate = wxPyBeginAllowThreads();
21509 (arg1)->GetPosition(arg2,arg3);
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 resultobj = SWIG_Py_Void();
21514 if (SWIG_IsTmpObj(res2)) {
21515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21516 } else {
21517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21519 }
21520 if (SWIG_IsTmpObj(res3)) {
21521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21522 } else {
21523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21525 }
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj = 0;
21534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21535 wxDC *arg2 = 0 ;
21536 wxPoint result;
21537 void *argp1 = 0 ;
21538 int res1 = 0 ;
21539 void *argp2 = 0 ;
21540 int res2 = 0 ;
21541 PyObject * obj0 = 0 ;
21542 PyObject * obj1 = 0 ;
21543 char * kwnames[] = {
21544 (char *) "self",(char *) "dc", NULL
21545 };
21546
21547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21549 if (!SWIG_IsOK(res1)) {
21550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21551 }
21552 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21553 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21554 if (!SWIG_IsOK(res2)) {
21555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21556 }
21557 if (!argp2) {
21558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21559 }
21560 arg2 = reinterpret_cast< wxDC * >(argp2);
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21568 return resultobj;
21569 fail:
21570 return NULL;
21571 }
21572
21573
21574 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21575 PyObject *resultobj = 0;
21576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21577 int result;
21578 void *argp1 = 0 ;
21579 int res1 = 0 ;
21580 PyObject *swig_obj[1] ;
21581
21582 if (!args) SWIG_fail;
21583 swig_obj[0] = args;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21587 }
21588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 result = (int)((wxMouseEvent const *)arg1)->GetX();
21592 wxPyEndAllowThreads(__tstate);
21593 if (PyErr_Occurred()) SWIG_fail;
21594 }
21595 resultobj = SWIG_From_int(static_cast< int >(result));
21596 return resultobj;
21597 fail:
21598 return NULL;
21599 }
21600
21601
21602 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21603 PyObject *resultobj = 0;
21604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21605 int result;
21606 void *argp1 = 0 ;
21607 int res1 = 0 ;
21608 PyObject *swig_obj[1] ;
21609
21610 if (!args) SWIG_fail;
21611 swig_obj[0] = args;
21612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21613 if (!SWIG_IsOK(res1)) {
21614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21615 }
21616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21617 {
21618 PyThreadState* __tstate = wxPyBeginAllowThreads();
21619 result = (int)((wxMouseEvent const *)arg1)->GetY();
21620 wxPyEndAllowThreads(__tstate);
21621 if (PyErr_Occurred()) SWIG_fail;
21622 }
21623 resultobj = SWIG_From_int(static_cast< int >(result));
21624 return resultobj;
21625 fail:
21626 return NULL;
21627 }
21628
21629
21630 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21631 PyObject *resultobj = 0;
21632 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21633 int result;
21634 void *argp1 = 0 ;
21635 int res1 = 0 ;
21636 PyObject *swig_obj[1] ;
21637
21638 if (!args) SWIG_fail;
21639 swig_obj[0] = args;
21640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21641 if (!SWIG_IsOK(res1)) {
21642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21643 }
21644 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21645 {
21646 PyThreadState* __tstate = wxPyBeginAllowThreads();
21647 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 resultobj = SWIG_From_int(static_cast< int >(result));
21652 return resultobj;
21653 fail:
21654 return NULL;
21655 }
21656
21657
21658 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21659 PyObject *resultobj = 0;
21660 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21661 int result;
21662 void *argp1 = 0 ;
21663 int res1 = 0 ;
21664 PyObject *swig_obj[1] ;
21665
21666 if (!args) SWIG_fail;
21667 swig_obj[0] = args;
21668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21669 if (!SWIG_IsOK(res1)) {
21670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21671 }
21672 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21676 wxPyEndAllowThreads(__tstate);
21677 if (PyErr_Occurred()) SWIG_fail;
21678 }
21679 resultobj = SWIG_From_int(static_cast< int >(result));
21680 return resultobj;
21681 fail:
21682 return NULL;
21683 }
21684
21685
21686 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21687 PyObject *resultobj = 0;
21688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21689 int result;
21690 void *argp1 = 0 ;
21691 int res1 = 0 ;
21692 PyObject *swig_obj[1] ;
21693
21694 if (!args) SWIG_fail;
21695 swig_obj[0] = args;
21696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21697 if (!SWIG_IsOK(res1)) {
21698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21699 }
21700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21701 {
21702 PyThreadState* __tstate = wxPyBeginAllowThreads();
21703 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21704 wxPyEndAllowThreads(__tstate);
21705 if (PyErr_Occurred()) SWIG_fail;
21706 }
21707 resultobj = SWIG_From_int(static_cast< int >(result));
21708 return resultobj;
21709 fail:
21710 return NULL;
21711 }
21712
21713
21714 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21715 PyObject *resultobj = 0;
21716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21717 bool result;
21718 void *argp1 = 0 ;
21719 int res1 = 0 ;
21720 PyObject *swig_obj[1] ;
21721
21722 if (!args) SWIG_fail;
21723 swig_obj[0] = args;
21724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21725 if (!SWIG_IsOK(res1)) {
21726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21727 }
21728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21729 {
21730 PyThreadState* __tstate = wxPyBeginAllowThreads();
21731 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21732 wxPyEndAllowThreads(__tstate);
21733 if (PyErr_Occurred()) SWIG_fail;
21734 }
21735 {
21736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21737 }
21738 return resultobj;
21739 fail:
21740 return NULL;
21741 }
21742
21743
21744 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21745 PyObject *resultobj = 0;
21746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21747 int arg2 ;
21748 void *argp1 = 0 ;
21749 int res1 = 0 ;
21750 int val2 ;
21751 int ecode2 = 0 ;
21752 PyObject *swig_obj[2] ;
21753
21754 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21756 if (!SWIG_IsOK(res1)) {
21757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21758 }
21759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21760 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21761 if (!SWIG_IsOK(ecode2)) {
21762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21763 }
21764 arg2 = static_cast< int >(val2);
21765 if (arg1) (arg1)->m_x = arg2;
21766
21767 resultobj = SWIG_Py_Void();
21768 return resultobj;
21769 fail:
21770 return NULL;
21771 }
21772
21773
21774 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21775 PyObject *resultobj = 0;
21776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21777 int result;
21778 void *argp1 = 0 ;
21779 int res1 = 0 ;
21780 PyObject *swig_obj[1] ;
21781
21782 if (!args) SWIG_fail;
21783 swig_obj[0] = args;
21784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21785 if (!SWIG_IsOK(res1)) {
21786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21787 }
21788 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21789 result = (int) ((arg1)->m_x);
21790 resultobj = SWIG_From_int(static_cast< int >(result));
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21798 PyObject *resultobj = 0;
21799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21800 int arg2 ;
21801 void *argp1 = 0 ;
21802 int res1 = 0 ;
21803 int val2 ;
21804 int ecode2 = 0 ;
21805 PyObject *swig_obj[2] ;
21806
21807 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21809 if (!SWIG_IsOK(res1)) {
21810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21811 }
21812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21813 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21814 if (!SWIG_IsOK(ecode2)) {
21815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21816 }
21817 arg2 = static_cast< int >(val2);
21818 if (arg1) (arg1)->m_y = arg2;
21819
21820 resultobj = SWIG_Py_Void();
21821 return resultobj;
21822 fail:
21823 return NULL;
21824 }
21825
21826
21827 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21828 PyObject *resultobj = 0;
21829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21830 int result;
21831 void *argp1 = 0 ;
21832 int res1 = 0 ;
21833 PyObject *swig_obj[1] ;
21834
21835 if (!args) SWIG_fail;
21836 swig_obj[0] = args;
21837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21838 if (!SWIG_IsOK(res1)) {
21839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21840 }
21841 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21842 result = (int) ((arg1)->m_y);
21843 resultobj = SWIG_From_int(static_cast< int >(result));
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21853 bool arg2 ;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 bool val2 ;
21857 int ecode2 = 0 ;
21858 PyObject *swig_obj[2] ;
21859
21860 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21862 if (!SWIG_IsOK(res1)) {
21863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21864 }
21865 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21866 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21867 if (!SWIG_IsOK(ecode2)) {
21868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21869 }
21870 arg2 = static_cast< bool >(val2);
21871 if (arg1) (arg1)->m_leftDown = arg2;
21872
21873 resultobj = SWIG_Py_Void();
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21881 PyObject *resultobj = 0;
21882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21883 bool result;
21884 void *argp1 = 0 ;
21885 int res1 = 0 ;
21886 PyObject *swig_obj[1] ;
21887
21888 if (!args) SWIG_fail;
21889 swig_obj[0] = args;
21890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21891 if (!SWIG_IsOK(res1)) {
21892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21893 }
21894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21895 result = (bool) ((arg1)->m_leftDown);
21896 {
21897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21898 }
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21906 PyObject *resultobj = 0;
21907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21908 bool arg2 ;
21909 void *argp1 = 0 ;
21910 int res1 = 0 ;
21911 bool val2 ;
21912 int ecode2 = 0 ;
21913 PyObject *swig_obj[2] ;
21914
21915 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21917 if (!SWIG_IsOK(res1)) {
21918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21919 }
21920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21921 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21922 if (!SWIG_IsOK(ecode2)) {
21923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21924 }
21925 arg2 = static_cast< bool >(val2);
21926 if (arg1) (arg1)->m_middleDown = arg2;
21927
21928 resultobj = SWIG_Py_Void();
21929 return resultobj;
21930 fail:
21931 return NULL;
21932 }
21933
21934
21935 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21936 PyObject *resultobj = 0;
21937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21938 bool result;
21939 void *argp1 = 0 ;
21940 int res1 = 0 ;
21941 PyObject *swig_obj[1] ;
21942
21943 if (!args) SWIG_fail;
21944 swig_obj[0] = args;
21945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21946 if (!SWIG_IsOK(res1)) {
21947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21948 }
21949 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21950 result = (bool) ((arg1)->m_middleDown);
21951 {
21952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21953 }
21954 return resultobj;
21955 fail:
21956 return NULL;
21957 }
21958
21959
21960 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21961 PyObject *resultobj = 0;
21962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21963 bool arg2 ;
21964 void *argp1 = 0 ;
21965 int res1 = 0 ;
21966 bool val2 ;
21967 int ecode2 = 0 ;
21968 PyObject *swig_obj[2] ;
21969
21970 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21972 if (!SWIG_IsOK(res1)) {
21973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21974 }
21975 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21976 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21977 if (!SWIG_IsOK(ecode2)) {
21978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21979 }
21980 arg2 = static_cast< bool >(val2);
21981 if (arg1) (arg1)->m_rightDown = arg2;
21982
21983 resultobj = SWIG_Py_Void();
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21991 PyObject *resultobj = 0;
21992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21993 bool result;
21994 void *argp1 = 0 ;
21995 int res1 = 0 ;
21996 PyObject *swig_obj[1] ;
21997
21998 if (!args) SWIG_fail;
21999 swig_obj[0] = args;
22000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22001 if (!SWIG_IsOK(res1)) {
22002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22003 }
22004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22005 result = (bool) ((arg1)->m_rightDown);
22006 {
22007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22008 }
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22016 PyObject *resultobj = 0;
22017 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22018 bool arg2 ;
22019 void *argp1 = 0 ;
22020 int res1 = 0 ;
22021 bool val2 ;
22022 int ecode2 = 0 ;
22023 PyObject *swig_obj[2] ;
22024
22025 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22027 if (!SWIG_IsOK(res1)) {
22028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22029 }
22030 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22031 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22032 if (!SWIG_IsOK(ecode2)) {
22033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22034 }
22035 arg2 = static_cast< bool >(val2);
22036 if (arg1) (arg1)->m_controlDown = arg2;
22037
22038 resultobj = SWIG_Py_Void();
22039 return resultobj;
22040 fail:
22041 return NULL;
22042 }
22043
22044
22045 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22046 PyObject *resultobj = 0;
22047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22048 bool result;
22049 void *argp1 = 0 ;
22050 int res1 = 0 ;
22051 PyObject *swig_obj[1] ;
22052
22053 if (!args) SWIG_fail;
22054 swig_obj[0] = args;
22055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22056 if (!SWIG_IsOK(res1)) {
22057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22058 }
22059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22060 result = (bool) ((arg1)->m_controlDown);
22061 {
22062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22063 }
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22071 PyObject *resultobj = 0;
22072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22073 bool arg2 ;
22074 void *argp1 = 0 ;
22075 int res1 = 0 ;
22076 bool val2 ;
22077 int ecode2 = 0 ;
22078 PyObject *swig_obj[2] ;
22079
22080 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22082 if (!SWIG_IsOK(res1)) {
22083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22084 }
22085 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22086 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22087 if (!SWIG_IsOK(ecode2)) {
22088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22089 }
22090 arg2 = static_cast< bool >(val2);
22091 if (arg1) (arg1)->m_shiftDown = arg2;
22092
22093 resultobj = SWIG_Py_Void();
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22101 PyObject *resultobj = 0;
22102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22103 bool result;
22104 void *argp1 = 0 ;
22105 int res1 = 0 ;
22106 PyObject *swig_obj[1] ;
22107
22108 if (!args) SWIG_fail;
22109 swig_obj[0] = args;
22110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22111 if (!SWIG_IsOK(res1)) {
22112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22113 }
22114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22115 result = (bool) ((arg1)->m_shiftDown);
22116 {
22117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22118 }
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22126 PyObject *resultobj = 0;
22127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22128 bool arg2 ;
22129 void *argp1 = 0 ;
22130 int res1 = 0 ;
22131 bool val2 ;
22132 int ecode2 = 0 ;
22133 PyObject *swig_obj[2] ;
22134
22135 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22137 if (!SWIG_IsOK(res1)) {
22138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22139 }
22140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22141 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22142 if (!SWIG_IsOK(ecode2)) {
22143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22144 }
22145 arg2 = static_cast< bool >(val2);
22146 if (arg1) (arg1)->m_altDown = arg2;
22147
22148 resultobj = SWIG_Py_Void();
22149 return resultobj;
22150 fail:
22151 return NULL;
22152 }
22153
22154
22155 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22156 PyObject *resultobj = 0;
22157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22158 bool result;
22159 void *argp1 = 0 ;
22160 int res1 = 0 ;
22161 PyObject *swig_obj[1] ;
22162
22163 if (!args) SWIG_fail;
22164 swig_obj[0] = args;
22165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22166 if (!SWIG_IsOK(res1)) {
22167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22168 }
22169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22170 result = (bool) ((arg1)->m_altDown);
22171 {
22172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22173 }
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *resultobj = 0;
22182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22183 bool arg2 ;
22184 void *argp1 = 0 ;
22185 int res1 = 0 ;
22186 bool val2 ;
22187 int ecode2 = 0 ;
22188 PyObject *swig_obj[2] ;
22189
22190 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22194 }
22195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22196 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22197 if (!SWIG_IsOK(ecode2)) {
22198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22199 }
22200 arg2 = static_cast< bool >(val2);
22201 if (arg1) (arg1)->m_metaDown = arg2;
22202
22203 resultobj = SWIG_Py_Void();
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22211 PyObject *resultobj = 0;
22212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22213 bool result;
22214 void *argp1 = 0 ;
22215 int res1 = 0 ;
22216 PyObject *swig_obj[1] ;
22217
22218 if (!args) SWIG_fail;
22219 swig_obj[0] = args;
22220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22221 if (!SWIG_IsOK(res1)) {
22222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22223 }
22224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22225 result = (bool) ((arg1)->m_metaDown);
22226 {
22227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22228 }
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22238 int arg2 ;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 int val2 ;
22242 int ecode2 = 0 ;
22243 PyObject *swig_obj[2] ;
22244
22245 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22247 if (!SWIG_IsOK(res1)) {
22248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22249 }
22250 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22251 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22252 if (!SWIG_IsOK(ecode2)) {
22253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22254 }
22255 arg2 = static_cast< int >(val2);
22256 if (arg1) (arg1)->m_wheelRotation = arg2;
22257
22258 resultobj = SWIG_Py_Void();
22259 return resultobj;
22260 fail:
22261 return NULL;
22262 }
22263
22264
22265 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22266 PyObject *resultobj = 0;
22267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22268 int result;
22269 void *argp1 = 0 ;
22270 int res1 = 0 ;
22271 PyObject *swig_obj[1] ;
22272
22273 if (!args) SWIG_fail;
22274 swig_obj[0] = args;
22275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22276 if (!SWIG_IsOK(res1)) {
22277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22278 }
22279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22280 result = (int) ((arg1)->m_wheelRotation);
22281 resultobj = SWIG_From_int(static_cast< int >(result));
22282 return resultobj;
22283 fail:
22284 return NULL;
22285 }
22286
22287
22288 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22289 PyObject *resultobj = 0;
22290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22291 int arg2 ;
22292 void *argp1 = 0 ;
22293 int res1 = 0 ;
22294 int val2 ;
22295 int ecode2 = 0 ;
22296 PyObject *swig_obj[2] ;
22297
22298 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22300 if (!SWIG_IsOK(res1)) {
22301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22302 }
22303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22304 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22305 if (!SWIG_IsOK(ecode2)) {
22306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22307 }
22308 arg2 = static_cast< int >(val2);
22309 if (arg1) (arg1)->m_wheelDelta = arg2;
22310
22311 resultobj = SWIG_Py_Void();
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22319 PyObject *resultobj = 0;
22320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22321 int result;
22322 void *argp1 = 0 ;
22323 int res1 = 0 ;
22324 PyObject *swig_obj[1] ;
22325
22326 if (!args) SWIG_fail;
22327 swig_obj[0] = args;
22328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22329 if (!SWIG_IsOK(res1)) {
22330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22331 }
22332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22333 result = (int) ((arg1)->m_wheelDelta);
22334 resultobj = SWIG_From_int(static_cast< int >(result));
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22342 PyObject *resultobj = 0;
22343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22344 int arg2 ;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 int val2 ;
22348 int ecode2 = 0 ;
22349 PyObject *swig_obj[2] ;
22350
22351 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22353 if (!SWIG_IsOK(res1)) {
22354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22355 }
22356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22357 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22358 if (!SWIG_IsOK(ecode2)) {
22359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22360 }
22361 arg2 = static_cast< int >(val2);
22362 if (arg1) (arg1)->m_linesPerAction = arg2;
22363
22364 resultobj = SWIG_Py_Void();
22365 return resultobj;
22366 fail:
22367 return NULL;
22368 }
22369
22370
22371 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22372 PyObject *resultobj = 0;
22373 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22374 int result;
22375 void *argp1 = 0 ;
22376 int res1 = 0 ;
22377 PyObject *swig_obj[1] ;
22378
22379 if (!args) SWIG_fail;
22380 swig_obj[0] = args;
22381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22382 if (!SWIG_IsOK(res1)) {
22383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22384 }
22385 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22386 result = (int) ((arg1)->m_linesPerAction);
22387 resultobj = SWIG_From_int(static_cast< int >(result));
22388 return resultobj;
22389 fail:
22390 return NULL;
22391 }
22392
22393
22394 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22395 PyObject *obj;
22396 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22397 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22398 return SWIG_Py_Void();
22399 }
22400
22401 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22402 return SWIG_Python_InitShadowInstance(args);
22403 }
22404
22405 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22406 PyObject *resultobj = 0;
22407 int arg1 = (int) 0 ;
22408 int arg2 = (int) 0 ;
22409 wxSetCursorEvent *result = 0 ;
22410 int val1 ;
22411 int ecode1 = 0 ;
22412 int val2 ;
22413 int ecode2 = 0 ;
22414 PyObject * obj0 = 0 ;
22415 PyObject * obj1 = 0 ;
22416 char * kwnames[] = {
22417 (char *) "x",(char *) "y", NULL
22418 };
22419
22420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22421 if (obj0) {
22422 ecode1 = SWIG_AsVal_int(obj0, &val1);
22423 if (!SWIG_IsOK(ecode1)) {
22424 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22425 }
22426 arg1 = static_cast< int >(val1);
22427 }
22428 if (obj1) {
22429 ecode2 = SWIG_AsVal_int(obj1, &val2);
22430 if (!SWIG_IsOK(ecode2)) {
22431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22432 }
22433 arg2 = static_cast< int >(val2);
22434 }
22435 {
22436 PyThreadState* __tstate = wxPyBeginAllowThreads();
22437 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22449 PyObject *resultobj = 0;
22450 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 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_wxSetCursorEvent, 0 | 0 );
22459 if (!SWIG_IsOK(res1)) {
22460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22461 }
22462 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22463 {
22464 PyThreadState* __tstate = wxPyBeginAllowThreads();
22465 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22466 wxPyEndAllowThreads(__tstate);
22467 if (PyErr_Occurred()) SWIG_fail;
22468 }
22469 resultobj = SWIG_From_int(static_cast< int >(result));
22470 return resultobj;
22471 fail:
22472 return NULL;
22473 }
22474
22475
22476 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22477 PyObject *resultobj = 0;
22478 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22479 int result;
22480 void *argp1 = 0 ;
22481 int res1 = 0 ;
22482 PyObject *swig_obj[1] ;
22483
22484 if (!args) SWIG_fail;
22485 swig_obj[0] = args;
22486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22487 if (!SWIG_IsOK(res1)) {
22488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22489 }
22490 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 resultobj = SWIG_From_int(static_cast< int >(result));
22498 return resultobj;
22499 fail:
22500 return NULL;
22501 }
22502
22503
22504 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22505 PyObject *resultobj = 0;
22506 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22507 wxCursor *arg2 = 0 ;
22508 void *argp1 = 0 ;
22509 int res1 = 0 ;
22510 void *argp2 = 0 ;
22511 int res2 = 0 ;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514 char * kwnames[] = {
22515 (char *) "self",(char *) "cursor", NULL
22516 };
22517
22518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22520 if (!SWIG_IsOK(res1)) {
22521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22522 }
22523 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22524 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22525 if (!SWIG_IsOK(res2)) {
22526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22527 }
22528 if (!argp2) {
22529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22530 }
22531 arg2 = reinterpret_cast< wxCursor * >(argp2);
22532 {
22533 PyThreadState* __tstate = wxPyBeginAllowThreads();
22534 (arg1)->SetCursor((wxCursor const &)*arg2);
22535 wxPyEndAllowThreads(__tstate);
22536 if (PyErr_Occurred()) SWIG_fail;
22537 }
22538 resultobj = SWIG_Py_Void();
22539 return resultobj;
22540 fail:
22541 return NULL;
22542 }
22543
22544
22545 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22546 PyObject *resultobj = 0;
22547 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22548 wxCursor *result = 0 ;
22549 void *argp1 = 0 ;
22550 int res1 = 0 ;
22551 PyObject *swig_obj[1] ;
22552
22553 if (!args) SWIG_fail;
22554 swig_obj[0] = args;
22555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22556 if (!SWIG_IsOK(res1)) {
22557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22558 }
22559 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22560 {
22561 PyThreadState* __tstate = wxPyBeginAllowThreads();
22562 {
22563 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22564 result = (wxCursor *) &_result_ref;
22565 }
22566 wxPyEndAllowThreads(__tstate);
22567 if (PyErr_Occurred()) SWIG_fail;
22568 }
22569 {
22570 wxCursor* resultptr = new wxCursor(*result);
22571 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22572 }
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22582 bool result;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 PyObject *swig_obj[1] ;
22586
22587 if (!args) SWIG_fail;
22588 swig_obj[0] = args;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22592 }
22593 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 {
22601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22602 }
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22610 PyObject *obj;
22611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22612 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22613 return SWIG_Py_Void();
22614 }
22615
22616 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22617 return SWIG_Python_InitShadowInstance(args);
22618 }
22619
22620 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22621 PyObject *resultobj = 0;
22622 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22623 wxKeyEvent *result = 0 ;
22624 int val1 ;
22625 int ecode1 = 0 ;
22626 PyObject * obj0 = 0 ;
22627 char * kwnames[] = {
22628 (char *) "eventType", NULL
22629 };
22630
22631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22632 if (obj0) {
22633 ecode1 = SWIG_AsVal_int(obj0, &val1);
22634 if (!SWIG_IsOK(ecode1)) {
22635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22636 }
22637 arg1 = static_cast< wxEventType >(val1);
22638 }
22639 {
22640 PyThreadState* __tstate = wxPyBeginAllowThreads();
22641 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22642 wxPyEndAllowThreads(__tstate);
22643 if (PyErr_Occurred()) SWIG_fail;
22644 }
22645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22646 return resultobj;
22647 fail:
22648 return NULL;
22649 }
22650
22651
22652 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22653 PyObject *resultobj = 0;
22654 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22655 int result;
22656 void *argp1 = 0 ;
22657 int res1 = 0 ;
22658 PyObject *swig_obj[1] ;
22659
22660 if (!args) SWIG_fail;
22661 swig_obj[0] = args;
22662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22663 if (!SWIG_IsOK(res1)) {
22664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22665 }
22666 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22667 {
22668 PyThreadState* __tstate = wxPyBeginAllowThreads();
22669 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22670 wxPyEndAllowThreads(__tstate);
22671 if (PyErr_Occurred()) SWIG_fail;
22672 }
22673 resultobj = SWIG_From_int(static_cast< int >(result));
22674 return resultobj;
22675 fail:
22676 return NULL;
22677 }
22678
22679
22680 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22681 PyObject *resultobj = 0;
22682 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22683 bool result;
22684 void *argp1 = 0 ;
22685 int res1 = 0 ;
22686 PyObject *swig_obj[1] ;
22687
22688 if (!args) SWIG_fail;
22689 swig_obj[0] = args;
22690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22691 if (!SWIG_IsOK(res1)) {
22692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22693 }
22694 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22695 {
22696 PyThreadState* __tstate = wxPyBeginAllowThreads();
22697 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22698 wxPyEndAllowThreads(__tstate);
22699 if (PyErr_Occurred()) SWIG_fail;
22700 }
22701 {
22702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22703 }
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22713 bool result;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 PyObject *swig_obj[1] ;
22717
22718 if (!args) SWIG_fail;
22719 swig_obj[0] = args;
22720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22721 if (!SWIG_IsOK(res1)) {
22722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22723 }
22724 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 {
22732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22733 }
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22741 PyObject *resultobj = 0;
22742 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22743 bool result;
22744 void *argp1 = 0 ;
22745 int res1 = 0 ;
22746 PyObject *swig_obj[1] ;
22747
22748 if (!args) SWIG_fail;
22749 swig_obj[0] = args;
22750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22751 if (!SWIG_IsOK(res1)) {
22752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22753 }
22754 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22758 wxPyEndAllowThreads(__tstate);
22759 if (PyErr_Occurred()) SWIG_fail;
22760 }
22761 {
22762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22763 }
22764 return resultobj;
22765 fail:
22766 return NULL;
22767 }
22768
22769
22770 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22771 PyObject *resultobj = 0;
22772 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22773 bool result;
22774 void *argp1 = 0 ;
22775 int res1 = 0 ;
22776 PyObject *swig_obj[1] ;
22777
22778 if (!args) SWIG_fail;
22779 swig_obj[0] = args;
22780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22781 if (!SWIG_IsOK(res1)) {
22782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22783 }
22784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22785 {
22786 PyThreadState* __tstate = wxPyBeginAllowThreads();
22787 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22788 wxPyEndAllowThreads(__tstate);
22789 if (PyErr_Occurred()) SWIG_fail;
22790 }
22791 {
22792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22793 }
22794 return resultobj;
22795 fail:
22796 return NULL;
22797 }
22798
22799
22800 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22801 PyObject *resultobj = 0;
22802 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22803 bool result;
22804 void *argp1 = 0 ;
22805 int res1 = 0 ;
22806 PyObject *swig_obj[1] ;
22807
22808 if (!args) SWIG_fail;
22809 swig_obj[0] = args;
22810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22811 if (!SWIG_IsOK(res1)) {
22812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22813 }
22814 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22815 {
22816 PyThreadState* __tstate = wxPyBeginAllowThreads();
22817 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22818 wxPyEndAllowThreads(__tstate);
22819 if (PyErr_Occurred()) SWIG_fail;
22820 }
22821 {
22822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22823 }
22824 return resultobj;
22825 fail:
22826 return NULL;
22827 }
22828
22829
22830 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22831 PyObject *resultobj = 0;
22832 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22833 bool result;
22834 void *argp1 = 0 ;
22835 int res1 = 0 ;
22836 PyObject *swig_obj[1] ;
22837
22838 if (!args) SWIG_fail;
22839 swig_obj[0] = args;
22840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22841 if (!SWIG_IsOK(res1)) {
22842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22843 }
22844 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22845 {
22846 PyThreadState* __tstate = wxPyBeginAllowThreads();
22847 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22848 wxPyEndAllowThreads(__tstate);
22849 if (PyErr_Occurred()) SWIG_fail;
22850 }
22851 {
22852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22853 }
22854 return resultobj;
22855 fail:
22856 return NULL;
22857 }
22858
22859
22860 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22861 PyObject *resultobj = 0;
22862 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22863 int result;
22864 void *argp1 = 0 ;
22865 int res1 = 0 ;
22866 PyObject *swig_obj[1] ;
22867
22868 if (!args) SWIG_fail;
22869 swig_obj[0] = args;
22870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22871 if (!SWIG_IsOK(res1)) {
22872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22873 }
22874 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22875 {
22876 PyThreadState* __tstate = wxPyBeginAllowThreads();
22877 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22878 wxPyEndAllowThreads(__tstate);
22879 if (PyErr_Occurred()) SWIG_fail;
22880 }
22881 resultobj = SWIG_From_int(static_cast< int >(result));
22882 return resultobj;
22883 fail:
22884 return NULL;
22885 }
22886
22887
22888 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22889 PyObject *resultobj = 0;
22890 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22891 int result;
22892 void *argp1 = 0 ;
22893 int res1 = 0 ;
22894 PyObject *swig_obj[1] ;
22895
22896 if (!args) SWIG_fail;
22897 swig_obj[0] = args;
22898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22899 if (!SWIG_IsOK(res1)) {
22900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22901 }
22902 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22903 {
22904 PyThreadState* __tstate = wxPyBeginAllowThreads();
22905 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22906 wxPyEndAllowThreads(__tstate);
22907 if (PyErr_Occurred()) SWIG_fail;
22908 }
22909 resultobj = SWIG_From_int(static_cast< int >(result));
22910 return resultobj;
22911 fail:
22912 return NULL;
22913 }
22914
22915
22916 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22917 PyObject *resultobj = 0;
22918 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22919 int arg2 ;
22920 void *argp1 = 0 ;
22921 int res1 = 0 ;
22922 int val2 ;
22923 int ecode2 = 0 ;
22924 PyObject * obj0 = 0 ;
22925 PyObject * obj1 = 0 ;
22926 char * kwnames[] = {
22927 (char *) "self",(char *) "uniChar", NULL
22928 };
22929
22930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22932 if (!SWIG_IsOK(res1)) {
22933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22934 }
22935 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22936 ecode2 = SWIG_AsVal_int(obj1, &val2);
22937 if (!SWIG_IsOK(ecode2)) {
22938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22939 }
22940 arg2 = static_cast< int >(val2);
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22944 wxPyEndAllowThreads(__tstate);
22945 if (PyErr_Occurred()) SWIG_fail;
22946 }
22947 resultobj = SWIG_Py_Void();
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22955 PyObject *resultobj = 0;
22956 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22957 unsigned int result;
22958 void *argp1 = 0 ;
22959 int res1 = 0 ;
22960 PyObject *swig_obj[1] ;
22961
22962 if (!args) SWIG_fail;
22963 swig_obj[0] = args;
22964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22965 if (!SWIG_IsOK(res1)) {
22966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22967 }
22968 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22969 {
22970 PyThreadState* __tstate = wxPyBeginAllowThreads();
22971 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22972 wxPyEndAllowThreads(__tstate);
22973 if (PyErr_Occurred()) SWIG_fail;
22974 }
22975 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22976 return resultobj;
22977 fail:
22978 return NULL;
22979 }
22980
22981
22982 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22983 PyObject *resultobj = 0;
22984 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22985 unsigned int result;
22986 void *argp1 = 0 ;
22987 int res1 = 0 ;
22988 PyObject *swig_obj[1] ;
22989
22990 if (!args) SWIG_fail;
22991 swig_obj[0] = args;
22992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22993 if (!SWIG_IsOK(res1)) {
22994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22995 }
22996 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22997 {
22998 PyThreadState* __tstate = wxPyBeginAllowThreads();
22999 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23000 wxPyEndAllowThreads(__tstate);
23001 if (PyErr_Occurred()) SWIG_fail;
23002 }
23003 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23004 return resultobj;
23005 fail:
23006 return NULL;
23007 }
23008
23009
23010 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23011 PyObject *resultobj = 0;
23012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23013 wxPoint result;
23014 void *argp1 = 0 ;
23015 int res1 = 0 ;
23016 PyObject *swig_obj[1] ;
23017
23018 if (!args) SWIG_fail;
23019 swig_obj[0] = args;
23020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23021 if (!SWIG_IsOK(res1)) {
23022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23023 }
23024 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23025 {
23026 PyThreadState* __tstate = wxPyBeginAllowThreads();
23027 result = (arg1)->GetPosition();
23028 wxPyEndAllowThreads(__tstate);
23029 if (PyErr_Occurred()) SWIG_fail;
23030 }
23031 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23039 PyObject *resultobj = 0;
23040 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23041 long *arg2 = (long *) 0 ;
23042 long *arg3 = (long *) 0 ;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 long temp2 ;
23046 int res2 = SWIG_TMPOBJ ;
23047 long temp3 ;
23048 int res3 = SWIG_TMPOBJ ;
23049 PyObject *swig_obj[1] ;
23050
23051 arg2 = &temp2;
23052 arg3 = &temp3;
23053 if (!args) SWIG_fail;
23054 swig_obj[0] = args;
23055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23056 if (!SWIG_IsOK(res1)) {
23057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23058 }
23059 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23060 {
23061 PyThreadState* __tstate = wxPyBeginAllowThreads();
23062 (arg1)->GetPosition(arg2,arg3);
23063 wxPyEndAllowThreads(__tstate);
23064 if (PyErr_Occurred()) SWIG_fail;
23065 }
23066 resultobj = SWIG_Py_Void();
23067 if (SWIG_IsTmpObj(res2)) {
23068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23069 } else {
23070 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23072 }
23073 if (SWIG_IsTmpObj(res3)) {
23074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23075 } else {
23076 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23078 }
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23086 PyObject *resultobj = 0;
23087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23088 int result;
23089 void *argp1 = 0 ;
23090 int res1 = 0 ;
23091 PyObject *swig_obj[1] ;
23092
23093 if (!args) SWIG_fail;
23094 swig_obj[0] = args;
23095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23096 if (!SWIG_IsOK(res1)) {
23097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23098 }
23099 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (int)((wxKeyEvent const *)arg1)->GetX();
23103 wxPyEndAllowThreads(__tstate);
23104 if (PyErr_Occurred()) SWIG_fail;
23105 }
23106 resultobj = SWIG_From_int(static_cast< int >(result));
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23114 PyObject *resultobj = 0;
23115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23116 int result;
23117 void *argp1 = 0 ;
23118 int res1 = 0 ;
23119 PyObject *swig_obj[1] ;
23120
23121 if (!args) SWIG_fail;
23122 swig_obj[0] = args;
23123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23124 if (!SWIG_IsOK(res1)) {
23125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23126 }
23127 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (int)((wxKeyEvent const *)arg1)->GetY();
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 resultobj = SWIG_From_int(static_cast< int >(result));
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 PyObject *resultobj = 0;
23143 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23144 int arg2 ;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 int val2 ;
23148 int ecode2 = 0 ;
23149 PyObject *swig_obj[2] ;
23150
23151 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23153 if (!SWIG_IsOK(res1)) {
23154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23155 }
23156 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23157 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23158 if (!SWIG_IsOK(ecode2)) {
23159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23160 }
23161 arg2 = static_cast< int >(val2);
23162 if (arg1) (arg1)->m_x = arg2;
23163
23164 resultobj = SWIG_Py_Void();
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23174 int result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23184 }
23185 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23186 result = (int) ((arg1)->m_x);
23187 resultobj = SWIG_From_int(static_cast< int >(result));
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23195 PyObject *resultobj = 0;
23196 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23197 int arg2 ;
23198 void *argp1 = 0 ;
23199 int res1 = 0 ;
23200 int val2 ;
23201 int ecode2 = 0 ;
23202 PyObject *swig_obj[2] ;
23203
23204 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23206 if (!SWIG_IsOK(res1)) {
23207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23208 }
23209 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23210 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23211 if (!SWIG_IsOK(ecode2)) {
23212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23213 }
23214 arg2 = static_cast< int >(val2);
23215 if (arg1) (arg1)->m_y = arg2;
23216
23217 resultobj = SWIG_Py_Void();
23218 return resultobj;
23219 fail:
23220 return NULL;
23221 }
23222
23223
23224 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23225 PyObject *resultobj = 0;
23226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23227 int result;
23228 void *argp1 = 0 ;
23229 int res1 = 0 ;
23230 PyObject *swig_obj[1] ;
23231
23232 if (!args) SWIG_fail;
23233 swig_obj[0] = args;
23234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23235 if (!SWIG_IsOK(res1)) {
23236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23237 }
23238 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23239 result = (int) ((arg1)->m_y);
23240 resultobj = SWIG_From_int(static_cast< int >(result));
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23248 PyObject *resultobj = 0;
23249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23250 long arg2 ;
23251 void *argp1 = 0 ;
23252 int res1 = 0 ;
23253 long val2 ;
23254 int ecode2 = 0 ;
23255 PyObject *swig_obj[2] ;
23256
23257 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23259 if (!SWIG_IsOK(res1)) {
23260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23261 }
23262 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23263 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23264 if (!SWIG_IsOK(ecode2)) {
23265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23266 }
23267 arg2 = static_cast< long >(val2);
23268 if (arg1) (arg1)->m_keyCode = arg2;
23269
23270 resultobj = SWIG_Py_Void();
23271 return resultobj;
23272 fail:
23273 return NULL;
23274 }
23275
23276
23277 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23278 PyObject *resultobj = 0;
23279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23280 long result;
23281 void *argp1 = 0 ;
23282 int res1 = 0 ;
23283 PyObject *swig_obj[1] ;
23284
23285 if (!args) SWIG_fail;
23286 swig_obj[0] = args;
23287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23288 if (!SWIG_IsOK(res1)) {
23289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23290 }
23291 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23292 result = (long) ((arg1)->m_keyCode);
23293 resultobj = SWIG_From_long(static_cast< long >(result));
23294 return resultobj;
23295 fail:
23296 return NULL;
23297 }
23298
23299
23300 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23301 PyObject *resultobj = 0;
23302 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23303 bool arg2 ;
23304 void *argp1 = 0 ;
23305 int res1 = 0 ;
23306 bool val2 ;
23307 int ecode2 = 0 ;
23308 PyObject *swig_obj[2] ;
23309
23310 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
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_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23314 }
23315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23316 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23317 if (!SWIG_IsOK(ecode2)) {
23318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23319 }
23320 arg2 = static_cast< bool >(val2);
23321 if (arg1) (arg1)->m_controlDown = arg2;
23322
23323 resultobj = SWIG_Py_Void();
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23331 PyObject *resultobj = 0;
23332 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23333 bool result;
23334 void *argp1 = 0 ;
23335 int res1 = 0 ;
23336 PyObject *swig_obj[1] ;
23337
23338 if (!args) SWIG_fail;
23339 swig_obj[0] = args;
23340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23341 if (!SWIG_IsOK(res1)) {
23342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23343 }
23344 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23345 result = (bool) ((arg1)->m_controlDown);
23346 {
23347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23348 }
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23356 PyObject *resultobj = 0;
23357 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23358 bool arg2 ;
23359 void *argp1 = 0 ;
23360 int res1 = 0 ;
23361 bool val2 ;
23362 int ecode2 = 0 ;
23363 PyObject *swig_obj[2] ;
23364
23365 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23367 if (!SWIG_IsOK(res1)) {
23368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23369 }
23370 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23371 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23372 if (!SWIG_IsOK(ecode2)) {
23373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23374 }
23375 arg2 = static_cast< bool >(val2);
23376 if (arg1) (arg1)->m_shiftDown = arg2;
23377
23378 resultobj = SWIG_Py_Void();
23379 return resultobj;
23380 fail:
23381 return NULL;
23382 }
23383
23384
23385 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23386 PyObject *resultobj = 0;
23387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23388 bool result;
23389 void *argp1 = 0 ;
23390 int res1 = 0 ;
23391 PyObject *swig_obj[1] ;
23392
23393 if (!args) SWIG_fail;
23394 swig_obj[0] = args;
23395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23396 if (!SWIG_IsOK(res1)) {
23397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23398 }
23399 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23400 result = (bool) ((arg1)->m_shiftDown);
23401 {
23402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23403 }
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23411 PyObject *resultobj = 0;
23412 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23413 bool arg2 ;
23414 void *argp1 = 0 ;
23415 int res1 = 0 ;
23416 bool val2 ;
23417 int ecode2 = 0 ;
23418 PyObject *swig_obj[2] ;
23419
23420 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23424 }
23425 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23426 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23427 if (!SWIG_IsOK(ecode2)) {
23428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23429 }
23430 arg2 = static_cast< bool >(val2);
23431 if (arg1) (arg1)->m_altDown = arg2;
23432
23433 resultobj = SWIG_Py_Void();
23434 return resultobj;
23435 fail:
23436 return NULL;
23437 }
23438
23439
23440 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23441 PyObject *resultobj = 0;
23442 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23443 bool result;
23444 void *argp1 = 0 ;
23445 int res1 = 0 ;
23446 PyObject *swig_obj[1] ;
23447
23448 if (!args) SWIG_fail;
23449 swig_obj[0] = args;
23450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23451 if (!SWIG_IsOK(res1)) {
23452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23453 }
23454 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23455 result = (bool) ((arg1)->m_altDown);
23456 {
23457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23458 }
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23466 PyObject *resultobj = 0;
23467 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23468 bool arg2 ;
23469 void *argp1 = 0 ;
23470 int res1 = 0 ;
23471 bool val2 ;
23472 int ecode2 = 0 ;
23473 PyObject *swig_obj[2] ;
23474
23475 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23477 if (!SWIG_IsOK(res1)) {
23478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23479 }
23480 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23481 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23482 if (!SWIG_IsOK(ecode2)) {
23483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23484 }
23485 arg2 = static_cast< bool >(val2);
23486 if (arg1) (arg1)->m_metaDown = arg2;
23487
23488 resultobj = SWIG_Py_Void();
23489 return resultobj;
23490 fail:
23491 return NULL;
23492 }
23493
23494
23495 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23496 PyObject *resultobj = 0;
23497 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23498 bool result;
23499 void *argp1 = 0 ;
23500 int res1 = 0 ;
23501 PyObject *swig_obj[1] ;
23502
23503 if (!args) SWIG_fail;
23504 swig_obj[0] = args;
23505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23506 if (!SWIG_IsOK(res1)) {
23507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23508 }
23509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23510 result = (bool) ((arg1)->m_metaDown);
23511 {
23512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23521 PyObject *resultobj = 0;
23522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23523 bool arg2 ;
23524 void *argp1 = 0 ;
23525 int res1 = 0 ;
23526 bool val2 ;
23527 int ecode2 = 0 ;
23528 PyObject *swig_obj[2] ;
23529
23530 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23532 if (!SWIG_IsOK(res1)) {
23533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23534 }
23535 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23536 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23537 if (!SWIG_IsOK(ecode2)) {
23538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23539 }
23540 arg2 = static_cast< bool >(val2);
23541 if (arg1) (arg1)->m_scanCode = arg2;
23542
23543 resultobj = SWIG_Py_Void();
23544 return resultobj;
23545 fail:
23546 return NULL;
23547 }
23548
23549
23550 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23551 PyObject *resultobj = 0;
23552 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23553 bool result;
23554 void *argp1 = 0 ;
23555 int res1 = 0 ;
23556 PyObject *swig_obj[1] ;
23557
23558 if (!args) SWIG_fail;
23559 swig_obj[0] = args;
23560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23561 if (!SWIG_IsOK(res1)) {
23562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23563 }
23564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23565 result = (bool) ((arg1)->m_scanCode);
23566 {
23567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23568 }
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23576 PyObject *resultobj = 0;
23577 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23578 unsigned int arg2 ;
23579 void *argp1 = 0 ;
23580 int res1 = 0 ;
23581 unsigned int val2 ;
23582 int ecode2 = 0 ;
23583 PyObject *swig_obj[2] ;
23584
23585 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23587 if (!SWIG_IsOK(res1)) {
23588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23589 }
23590 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23591 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23592 if (!SWIG_IsOK(ecode2)) {
23593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23594 }
23595 arg2 = static_cast< unsigned int >(val2);
23596 if (arg1) (arg1)->m_rawCode = arg2;
23597
23598 resultobj = SWIG_Py_Void();
23599 return resultobj;
23600 fail:
23601 return NULL;
23602 }
23603
23604
23605 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23606 PyObject *resultobj = 0;
23607 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23608 unsigned int result;
23609 void *argp1 = 0 ;
23610 int res1 = 0 ;
23611 PyObject *swig_obj[1] ;
23612
23613 if (!args) SWIG_fail;
23614 swig_obj[0] = args;
23615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23616 if (!SWIG_IsOK(res1)) {
23617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23618 }
23619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23620 result = (unsigned int) ((arg1)->m_rawCode);
23621 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23622 return resultobj;
23623 fail:
23624 return NULL;
23625 }
23626
23627
23628 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23629 PyObject *resultobj = 0;
23630 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23631 unsigned int arg2 ;
23632 void *argp1 = 0 ;
23633 int res1 = 0 ;
23634 unsigned int val2 ;
23635 int ecode2 = 0 ;
23636 PyObject *swig_obj[2] ;
23637
23638 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23640 if (!SWIG_IsOK(res1)) {
23641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23642 }
23643 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23644 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23645 if (!SWIG_IsOK(ecode2)) {
23646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23647 }
23648 arg2 = static_cast< unsigned int >(val2);
23649 if (arg1) (arg1)->m_rawFlags = arg2;
23650
23651 resultobj = SWIG_Py_Void();
23652 return resultobj;
23653 fail:
23654 return NULL;
23655 }
23656
23657
23658 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23659 PyObject *resultobj = 0;
23660 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23661 unsigned int result;
23662 void *argp1 = 0 ;
23663 int res1 = 0 ;
23664 PyObject *swig_obj[1] ;
23665
23666 if (!args) SWIG_fail;
23667 swig_obj[0] = args;
23668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23669 if (!SWIG_IsOK(res1)) {
23670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23671 }
23672 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23673 result = (unsigned int) ((arg1)->m_rawFlags);
23674 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23682 PyObject *obj;
23683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23684 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23685 return SWIG_Py_Void();
23686 }
23687
23688 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23689 return SWIG_Python_InitShadowInstance(args);
23690 }
23691
23692 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23693 PyObject *resultobj = 0;
23694 wxSize const &arg1_defvalue = wxDefaultSize ;
23695 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23696 int arg2 = (int) 0 ;
23697 wxSizeEvent *result = 0 ;
23698 wxSize temp1 ;
23699 int val2 ;
23700 int ecode2 = 0 ;
23701 PyObject * obj0 = 0 ;
23702 PyObject * obj1 = 0 ;
23703 char * kwnames[] = {
23704 (char *) "sz",(char *) "winid", NULL
23705 };
23706
23707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23708 if (obj0) {
23709 {
23710 arg1 = &temp1;
23711 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23712 }
23713 }
23714 if (obj1) {
23715 ecode2 = SWIG_AsVal_int(obj1, &val2);
23716 if (!SWIG_IsOK(ecode2)) {
23717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23718 }
23719 arg2 = static_cast< int >(val2);
23720 }
23721 {
23722 PyThreadState* __tstate = wxPyBeginAllowThreads();
23723 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23724 wxPyEndAllowThreads(__tstate);
23725 if (PyErr_Occurred()) SWIG_fail;
23726 }
23727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23735 PyObject *resultobj = 0;
23736 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23737 wxSize result;
23738 void *argp1 = 0 ;
23739 int res1 = 0 ;
23740 PyObject *swig_obj[1] ;
23741
23742 if (!args) SWIG_fail;
23743 swig_obj[0] = args;
23744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23745 if (!SWIG_IsOK(res1)) {
23746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23747 }
23748 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = ((wxSizeEvent const *)arg1)->GetSize();
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23763 PyObject *resultobj = 0;
23764 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23765 wxRect result;
23766 void *argp1 = 0 ;
23767 int res1 = 0 ;
23768 PyObject *swig_obj[1] ;
23769
23770 if (!args) SWIG_fail;
23771 swig_obj[0] = args;
23772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23773 if (!SWIG_IsOK(res1)) {
23774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23775 }
23776 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23777 {
23778 PyThreadState* __tstate = wxPyBeginAllowThreads();
23779 result = ((wxSizeEvent const *)arg1)->GetRect();
23780 wxPyEndAllowThreads(__tstate);
23781 if (PyErr_Occurred()) SWIG_fail;
23782 }
23783 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23791 PyObject *resultobj = 0;
23792 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23793 wxRect arg2 ;
23794 void *argp1 = 0 ;
23795 int res1 = 0 ;
23796 void *argp2 ;
23797 int res2 = 0 ;
23798 PyObject * obj0 = 0 ;
23799 PyObject * obj1 = 0 ;
23800 char * kwnames[] = {
23801 (char *) "self",(char *) "rect", NULL
23802 };
23803
23804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23808 }
23809 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23810 {
23811 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23812 if (!SWIG_IsOK(res2)) {
23813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23814 }
23815 if (!argp2) {
23816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23817 } else {
23818 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23819 arg2 = *temp;
23820 if (SWIG_IsNewObj(res2)) delete temp;
23821 }
23822 }
23823 {
23824 PyThreadState* __tstate = wxPyBeginAllowThreads();
23825 (arg1)->SetRect(arg2);
23826 wxPyEndAllowThreads(__tstate);
23827 if (PyErr_Occurred()) SWIG_fail;
23828 }
23829 resultobj = SWIG_Py_Void();
23830 return resultobj;
23831 fail:
23832 return NULL;
23833 }
23834
23835
23836 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj = 0;
23838 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23839 wxSize arg2 ;
23840 void *argp1 = 0 ;
23841 int res1 = 0 ;
23842 void *argp2 ;
23843 int res2 = 0 ;
23844 PyObject * obj0 = 0 ;
23845 PyObject * obj1 = 0 ;
23846 char * kwnames[] = {
23847 (char *) "self",(char *) "size", NULL
23848 };
23849
23850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23852 if (!SWIG_IsOK(res1)) {
23853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23854 }
23855 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23856 {
23857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23858 if (!SWIG_IsOK(res2)) {
23859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23860 }
23861 if (!argp2) {
23862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23863 } else {
23864 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23865 arg2 = *temp;
23866 if (SWIG_IsNewObj(res2)) delete temp;
23867 }
23868 }
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 wxSizeEvent_SetSize(arg1,arg2);
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_Py_Void();
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *resultobj = 0;
23884 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23885 wxSize *arg2 = (wxSize *) 0 ;
23886 void *argp1 = 0 ;
23887 int res1 = 0 ;
23888 void *argp2 = 0 ;
23889 int res2 = 0 ;
23890 PyObject *swig_obj[2] ;
23891
23892 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23894 if (!SWIG_IsOK(res1)) {
23895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23896 }
23897 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23898 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23899 if (!SWIG_IsOK(res2)) {
23900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23901 }
23902 arg2 = reinterpret_cast< wxSize * >(argp2);
23903 if (arg1) (arg1)->m_size = *arg2;
23904
23905 resultobj = SWIG_Py_Void();
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23913 PyObject *resultobj = 0;
23914 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23915 wxSize *result = 0 ;
23916 void *argp1 = 0 ;
23917 int res1 = 0 ;
23918 PyObject *swig_obj[1] ;
23919
23920 if (!args) SWIG_fail;
23921 swig_obj[0] = args;
23922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23923 if (!SWIG_IsOK(res1)) {
23924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23925 }
23926 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23927 result = (wxSize *)& ((arg1)->m_size);
23928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 PyObject *resultobj = 0;
23937 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23938 wxRect *arg2 = (wxRect *) 0 ;
23939 void *argp1 = 0 ;
23940 int res1 = 0 ;
23941 void *argp2 = 0 ;
23942 int res2 = 0 ;
23943 PyObject *swig_obj[2] ;
23944
23945 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23947 if (!SWIG_IsOK(res1)) {
23948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23949 }
23950 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23951 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23952 if (!SWIG_IsOK(res2)) {
23953 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23954 }
23955 arg2 = reinterpret_cast< wxRect * >(argp2);
23956 if (arg1) (arg1)->m_rect = *arg2;
23957
23958 resultobj = SWIG_Py_Void();
23959 return resultobj;
23960 fail:
23961 return NULL;
23962 }
23963
23964
23965 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23966 PyObject *resultobj = 0;
23967 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23968 wxRect *result = 0 ;
23969 void *argp1 = 0 ;
23970 int res1 = 0 ;
23971 PyObject *swig_obj[1] ;
23972
23973 if (!args) SWIG_fail;
23974 swig_obj[0] = args;
23975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23976 if (!SWIG_IsOK(res1)) {
23977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23978 }
23979 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23980 result = (wxRect *)& ((arg1)->m_rect);
23981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23989 PyObject *obj;
23990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23991 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23992 return SWIG_Py_Void();
23993 }
23994
23995 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23996 return SWIG_Python_InitShadowInstance(args);
23997 }
23998
23999 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj = 0;
24001 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24002 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24003 int arg2 = (int) 0 ;
24004 wxMoveEvent *result = 0 ;
24005 wxPoint temp1 ;
24006 int val2 ;
24007 int ecode2 = 0 ;
24008 PyObject * obj0 = 0 ;
24009 PyObject * obj1 = 0 ;
24010 char * kwnames[] = {
24011 (char *) "pos",(char *) "winid", NULL
24012 };
24013
24014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24015 if (obj0) {
24016 {
24017 arg1 = &temp1;
24018 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24019 }
24020 }
24021 if (obj1) {
24022 ecode2 = SWIG_AsVal_int(obj1, &val2);
24023 if (!SWIG_IsOK(ecode2)) {
24024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24025 }
24026 arg2 = static_cast< int >(val2);
24027 }
24028 {
24029 PyThreadState* __tstate = wxPyBeginAllowThreads();
24030 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24031 wxPyEndAllowThreads(__tstate);
24032 if (PyErr_Occurred()) SWIG_fail;
24033 }
24034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24035 return resultobj;
24036 fail:
24037 return NULL;
24038 }
24039
24040
24041 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24042 PyObject *resultobj = 0;
24043 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24044 wxPoint result;
24045 void *argp1 = 0 ;
24046 int res1 = 0 ;
24047 PyObject *swig_obj[1] ;
24048
24049 if (!args) SWIG_fail;
24050 swig_obj[0] = args;
24051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24052 if (!SWIG_IsOK(res1)) {
24053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24054 }
24055 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24056 {
24057 PyThreadState* __tstate = wxPyBeginAllowThreads();
24058 result = ((wxMoveEvent const *)arg1)->GetPosition();
24059 wxPyEndAllowThreads(__tstate);
24060 if (PyErr_Occurred()) SWIG_fail;
24061 }
24062 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24063 return resultobj;
24064 fail:
24065 return NULL;
24066 }
24067
24068
24069 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24070 PyObject *resultobj = 0;
24071 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24072 wxRect result;
24073 void *argp1 = 0 ;
24074 int res1 = 0 ;
24075 PyObject *swig_obj[1] ;
24076
24077 if (!args) SWIG_fail;
24078 swig_obj[0] = args;
24079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24080 if (!SWIG_IsOK(res1)) {
24081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24082 }
24083 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 result = ((wxMoveEvent const *)arg1)->GetRect();
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj = 0;
24099 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24100 wxRect *arg2 = 0 ;
24101 void *argp1 = 0 ;
24102 int res1 = 0 ;
24103 wxRect temp2 ;
24104 PyObject * obj0 = 0 ;
24105 PyObject * obj1 = 0 ;
24106 char * kwnames[] = {
24107 (char *) "self",(char *) "rect", NULL
24108 };
24109
24110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24112 if (!SWIG_IsOK(res1)) {
24113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24114 }
24115 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24116 {
24117 arg2 = &temp2;
24118 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24119 }
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 (arg1)->SetRect((wxRect const &)*arg2);
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 resultobj = SWIG_Py_Void();
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24134 PyObject *resultobj = 0;
24135 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24136 wxPoint *arg2 = 0 ;
24137 void *argp1 = 0 ;
24138 int res1 = 0 ;
24139 wxPoint temp2 ;
24140 PyObject * obj0 = 0 ;
24141 PyObject * obj1 = 0 ;
24142 char * kwnames[] = {
24143 (char *) "self",(char *) "pos", NULL
24144 };
24145
24146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24148 if (!SWIG_IsOK(res1)) {
24149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24150 }
24151 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24152 {
24153 arg2 = &temp2;
24154 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24155 }
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 (arg1)->SetPosition((wxPoint const &)*arg2);
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 resultobj = SWIG_Py_Void();
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24170 PyObject *obj;
24171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24172 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24173 return SWIG_Py_Void();
24174 }
24175
24176 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24177 return SWIG_Python_InitShadowInstance(args);
24178 }
24179
24180 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24181 PyObject *resultobj = 0;
24182 int arg1 = (int) 0 ;
24183 wxPaintEvent *result = 0 ;
24184 int val1 ;
24185 int ecode1 = 0 ;
24186 PyObject * obj0 = 0 ;
24187 char * kwnames[] = {
24188 (char *) "Id", NULL
24189 };
24190
24191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24192 if (obj0) {
24193 ecode1 = SWIG_AsVal_int(obj0, &val1);
24194 if (!SWIG_IsOK(ecode1)) {
24195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24196 }
24197 arg1 = static_cast< int >(val1);
24198 }
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24213 PyObject *obj;
24214 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24215 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24216 return SWIG_Py_Void();
24217 }
24218
24219 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24220 return SWIG_Python_InitShadowInstance(args);
24221 }
24222
24223 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj = 0;
24225 int arg1 = (int) 0 ;
24226 wxNcPaintEvent *result = 0 ;
24227 int val1 ;
24228 int ecode1 = 0 ;
24229 PyObject * obj0 = 0 ;
24230 char * kwnames[] = {
24231 (char *) "winid", NULL
24232 };
24233
24234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24235 if (obj0) {
24236 ecode1 = SWIG_AsVal_int(obj0, &val1);
24237 if (!SWIG_IsOK(ecode1)) {
24238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24239 }
24240 arg1 = static_cast< int >(val1);
24241 }
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24245 wxPyEndAllowThreads(__tstate);
24246 if (PyErr_Occurred()) SWIG_fail;
24247 }
24248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24249 return resultobj;
24250 fail:
24251 return NULL;
24252 }
24253
24254
24255 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24256 PyObject *obj;
24257 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24258 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24259 return SWIG_Py_Void();
24260 }
24261
24262 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24263 return SWIG_Python_InitShadowInstance(args);
24264 }
24265
24266 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24267 PyObject *resultobj = 0;
24268 int arg1 = (int) 0 ;
24269 wxDC *arg2 = (wxDC *) NULL ;
24270 wxEraseEvent *result = 0 ;
24271 int val1 ;
24272 int ecode1 = 0 ;
24273 void *argp2 = 0 ;
24274 int res2 = 0 ;
24275 PyObject * obj0 = 0 ;
24276 PyObject * obj1 = 0 ;
24277 char * kwnames[] = {
24278 (char *) "Id",(char *) "dc", NULL
24279 };
24280
24281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24282 if (obj0) {
24283 ecode1 = SWIG_AsVal_int(obj0, &val1);
24284 if (!SWIG_IsOK(ecode1)) {
24285 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24286 }
24287 arg1 = static_cast< int >(val1);
24288 }
24289 if (obj1) {
24290 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24291 if (!SWIG_IsOK(res2)) {
24292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24293 }
24294 arg2 = reinterpret_cast< wxDC * >(argp2);
24295 }
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24312 wxDC *result = 0 ;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 PyObject *swig_obj[1] ;
24316
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24322 }
24323 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 {
24331 resultobj = wxPyMake_wxObject(result, (bool)0);
24332 }
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *obj;
24341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24342 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24343 return SWIG_Py_Void();
24344 }
24345
24346 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24347 return SWIG_Python_InitShadowInstance(args);
24348 }
24349
24350 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24353 int arg2 = (int) 0 ;
24354 wxFocusEvent *result = 0 ;
24355 int val1 ;
24356 int ecode1 = 0 ;
24357 int val2 ;
24358 int ecode2 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "type",(char *) "winid", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24366 if (obj0) {
24367 ecode1 = SWIG_AsVal_int(obj0, &val1);
24368 if (!SWIG_IsOK(ecode1)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24370 }
24371 arg1 = static_cast< wxEventType >(val1);
24372 }
24373 if (obj1) {
24374 ecode2 = SWIG_AsVal_int(obj1, &val2);
24375 if (!SWIG_IsOK(ecode2)) {
24376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24377 }
24378 arg2 = static_cast< int >(val2);
24379 }
24380 {
24381 PyThreadState* __tstate = wxPyBeginAllowThreads();
24382 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 PyObject *resultobj = 0;
24395 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24396 wxWindow *result = 0 ;
24397 void *argp1 = 0 ;
24398 int res1 = 0 ;
24399 PyObject *swig_obj[1] ;
24400
24401 if (!args) SWIG_fail;
24402 swig_obj[0] = args;
24403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24404 if (!SWIG_IsOK(res1)) {
24405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24406 }
24407 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24408 {
24409 PyThreadState* __tstate = wxPyBeginAllowThreads();
24410 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24411 wxPyEndAllowThreads(__tstate);
24412 if (PyErr_Occurred()) SWIG_fail;
24413 }
24414 {
24415 resultobj = wxPyMake_wxObject(result, (bool)0);
24416 }
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj = 0;
24425 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24426 wxWindow *arg2 = (wxWindow *) 0 ;
24427 void *argp1 = 0 ;
24428 int res1 = 0 ;
24429 void *argp2 = 0 ;
24430 int res2 = 0 ;
24431 PyObject * obj0 = 0 ;
24432 PyObject * obj1 = 0 ;
24433 char * kwnames[] = {
24434 (char *) "self",(char *) "win", NULL
24435 };
24436
24437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24439 if (!SWIG_IsOK(res1)) {
24440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24441 }
24442 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24443 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24444 if (!SWIG_IsOK(res2)) {
24445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24446 }
24447 arg2 = reinterpret_cast< wxWindow * >(argp2);
24448 {
24449 PyThreadState* __tstate = wxPyBeginAllowThreads();
24450 (arg1)->SetWindow(arg2);
24451 wxPyEndAllowThreads(__tstate);
24452 if (PyErr_Occurred()) SWIG_fail;
24453 }
24454 resultobj = SWIG_Py_Void();
24455 return resultobj;
24456 fail:
24457 return NULL;
24458 }
24459
24460
24461 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 PyObject *obj;
24463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24464 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24465 return SWIG_Py_Void();
24466 }
24467
24468 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24469 return SWIG_Python_InitShadowInstance(args);
24470 }
24471
24472 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24473 PyObject *resultobj = 0;
24474 wxWindow *arg1 = (wxWindow *) NULL ;
24475 wxChildFocusEvent *result = 0 ;
24476 void *argp1 = 0 ;
24477 int res1 = 0 ;
24478 PyObject * obj0 = 0 ;
24479 char * kwnames[] = {
24480 (char *) "win", NULL
24481 };
24482
24483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24484 if (obj0) {
24485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24488 }
24489 arg1 = reinterpret_cast< wxWindow * >(argp1);
24490 }
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 PyObject *resultobj = 0;
24506 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24507 wxWindow *result = 0 ;
24508 void *argp1 = 0 ;
24509 int res1 = 0 ;
24510 PyObject *swig_obj[1] ;
24511
24512 if (!args) SWIG_fail;
24513 swig_obj[0] = args;
24514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24515 if (!SWIG_IsOK(res1)) {
24516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24517 }
24518 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 {
24526 resultobj = wxPyMake_wxObject(result, (bool)0);
24527 }
24528 return resultobj;
24529 fail:
24530 return NULL;
24531 }
24532
24533
24534 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24535 PyObject *obj;
24536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24537 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24538 return SWIG_Py_Void();
24539 }
24540
24541 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24542 return SWIG_Python_InitShadowInstance(args);
24543 }
24544
24545 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24546 PyObject *resultobj = 0;
24547 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24548 bool arg2 = (bool) true ;
24549 int arg3 = (int) 0 ;
24550 wxActivateEvent *result = 0 ;
24551 int val1 ;
24552 int ecode1 = 0 ;
24553 bool val2 ;
24554 int ecode2 = 0 ;
24555 int val3 ;
24556 int ecode3 = 0 ;
24557 PyObject * obj0 = 0 ;
24558 PyObject * obj1 = 0 ;
24559 PyObject * obj2 = 0 ;
24560 char * kwnames[] = {
24561 (char *) "type",(char *) "active",(char *) "Id", NULL
24562 };
24563
24564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24565 if (obj0) {
24566 ecode1 = SWIG_AsVal_int(obj0, &val1);
24567 if (!SWIG_IsOK(ecode1)) {
24568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24569 }
24570 arg1 = static_cast< wxEventType >(val1);
24571 }
24572 if (obj1) {
24573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24574 if (!SWIG_IsOK(ecode2)) {
24575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24576 }
24577 arg2 = static_cast< bool >(val2);
24578 }
24579 if (obj2) {
24580 ecode3 = SWIG_AsVal_int(obj2, &val3);
24581 if (!SWIG_IsOK(ecode3)) {
24582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24583 }
24584 arg3 = static_cast< int >(val3);
24585 }
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24589 wxPyEndAllowThreads(__tstate);
24590 if (PyErr_Occurred()) SWIG_fail;
24591 }
24592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24593 return resultobj;
24594 fail:
24595 return NULL;
24596 }
24597
24598
24599 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 PyObject *resultobj = 0;
24601 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24602 bool result;
24603 void *argp1 = 0 ;
24604 int res1 = 0 ;
24605 PyObject *swig_obj[1] ;
24606
24607 if (!args) SWIG_fail;
24608 swig_obj[0] = args;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24612 }
24613 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24614 {
24615 PyThreadState* __tstate = wxPyBeginAllowThreads();
24616 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24617 wxPyEndAllowThreads(__tstate);
24618 if (PyErr_Occurred()) SWIG_fail;
24619 }
24620 {
24621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24622 }
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *obj;
24631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24632 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24633 return SWIG_Py_Void();
24634 }
24635
24636 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24637 return SWIG_Python_InitShadowInstance(args);
24638 }
24639
24640 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 int arg1 = (int) 0 ;
24643 wxInitDialogEvent *result = 0 ;
24644 int val1 ;
24645 int ecode1 = 0 ;
24646 PyObject * obj0 = 0 ;
24647 char * kwnames[] = {
24648 (char *) "Id", NULL
24649 };
24650
24651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24652 if (obj0) {
24653 ecode1 = SWIG_AsVal_int(obj0, &val1);
24654 if (!SWIG_IsOK(ecode1)) {
24655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24656 }
24657 arg1 = static_cast< int >(val1);
24658 }
24659 {
24660 PyThreadState* __tstate = wxPyBeginAllowThreads();
24661 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24662 wxPyEndAllowThreads(__tstate);
24663 if (PyErr_Occurred()) SWIG_fail;
24664 }
24665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 PyObject *obj;
24674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24675 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24676 return SWIG_Py_Void();
24677 }
24678
24679 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24680 return SWIG_Python_InitShadowInstance(args);
24681 }
24682
24683 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj = 0;
24685 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24686 int arg2 = (int) 0 ;
24687 wxMenu *arg3 = (wxMenu *) NULL ;
24688 wxMenuEvent *result = 0 ;
24689 int val1 ;
24690 int ecode1 = 0 ;
24691 int val2 ;
24692 int ecode2 = 0 ;
24693 void *argp3 = 0 ;
24694 int res3 = 0 ;
24695 PyObject * obj0 = 0 ;
24696 PyObject * obj1 = 0 ;
24697 PyObject * obj2 = 0 ;
24698 char * kwnames[] = {
24699 (char *) "type",(char *) "winid",(char *) "menu", NULL
24700 };
24701
24702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24703 if (obj0) {
24704 ecode1 = SWIG_AsVal_int(obj0, &val1);
24705 if (!SWIG_IsOK(ecode1)) {
24706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24707 }
24708 arg1 = static_cast< wxEventType >(val1);
24709 }
24710 if (obj1) {
24711 ecode2 = SWIG_AsVal_int(obj1, &val2);
24712 if (!SWIG_IsOK(ecode2)) {
24713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24714 }
24715 arg2 = static_cast< int >(val2);
24716 }
24717 if (obj2) {
24718 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24719 if (!SWIG_IsOK(res3)) {
24720 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24721 }
24722 arg3 = reinterpret_cast< wxMenu * >(argp3);
24723 }
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24731 return resultobj;
24732 fail:
24733 return NULL;
24734 }
24735
24736
24737 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24738 PyObject *resultobj = 0;
24739 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24740 int result;
24741 void *argp1 = 0 ;
24742 int res1 = 0 ;
24743 PyObject *swig_obj[1] ;
24744
24745 if (!args) SWIG_fail;
24746 swig_obj[0] = args;
24747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24748 if (!SWIG_IsOK(res1)) {
24749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24750 }
24751 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 resultobj = SWIG_From_int(static_cast< int >(result));
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24766 PyObject *resultobj = 0;
24767 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24768 bool result;
24769 void *argp1 = 0 ;
24770 int res1 = 0 ;
24771 PyObject *swig_obj[1] ;
24772
24773 if (!args) SWIG_fail;
24774 swig_obj[0] = args;
24775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24778 }
24779 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24780 {
24781 PyThreadState* __tstate = wxPyBeginAllowThreads();
24782 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24788 }
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24796 PyObject *resultobj = 0;
24797 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24798 wxMenu *result = 0 ;
24799 void *argp1 = 0 ;
24800 int res1 = 0 ;
24801 PyObject *swig_obj[1] ;
24802
24803 if (!args) SWIG_fail;
24804 swig_obj[0] = args;
24805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24806 if (!SWIG_IsOK(res1)) {
24807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24808 }
24809 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24810 {
24811 PyThreadState* __tstate = wxPyBeginAllowThreads();
24812 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24813 wxPyEndAllowThreads(__tstate);
24814 if (PyErr_Occurred()) SWIG_fail;
24815 }
24816 {
24817 resultobj = wxPyMake_wxObject(result, (bool)0);
24818 }
24819 return resultobj;
24820 fail:
24821 return NULL;
24822 }
24823
24824
24825 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24826 PyObject *obj;
24827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24828 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24829 return SWIG_Py_Void();
24830 }
24831
24832 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24833 return SWIG_Python_InitShadowInstance(args);
24834 }
24835
24836 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24837 PyObject *resultobj = 0;
24838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24839 int arg2 = (int) 0 ;
24840 wxCloseEvent *result = 0 ;
24841 int val1 ;
24842 int ecode1 = 0 ;
24843 int val2 ;
24844 int ecode2 = 0 ;
24845 PyObject * obj0 = 0 ;
24846 PyObject * obj1 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "type",(char *) "winid", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24852 if (obj0) {
24853 ecode1 = SWIG_AsVal_int(obj0, &val1);
24854 if (!SWIG_IsOK(ecode1)) {
24855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24856 }
24857 arg1 = static_cast< wxEventType >(val1);
24858 }
24859 if (obj1) {
24860 ecode2 = SWIG_AsVal_int(obj1, &val2);
24861 if (!SWIG_IsOK(ecode2)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24863 }
24864 arg2 = static_cast< int >(val2);
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj = 0;
24881 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24882 bool arg2 ;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 bool val2 ;
24886 int ecode2 = 0 ;
24887 PyObject * obj0 = 0 ;
24888 PyObject * obj1 = 0 ;
24889 char * kwnames[] = {
24890 (char *) "self",(char *) "logOff", NULL
24891 };
24892
24893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24895 if (!SWIG_IsOK(res1)) {
24896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24897 }
24898 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24899 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24900 if (!SWIG_IsOK(ecode2)) {
24901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24902 }
24903 arg2 = static_cast< bool >(val2);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 (arg1)->SetLoggingOff(arg2);
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 resultobj = SWIG_Py_Void();
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *resultobj = 0;
24919 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24920 bool result;
24921 void *argp1 = 0 ;
24922 int res1 = 0 ;
24923 PyObject *swig_obj[1] ;
24924
24925 if (!args) SWIG_fail;
24926 swig_obj[0] = args;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24930 }
24931 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 {
24939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24940 }
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24948 PyObject *resultobj = 0;
24949 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24950 bool arg2 = (bool) true ;
24951 void *argp1 = 0 ;
24952 int res1 = 0 ;
24953 bool val2 ;
24954 int ecode2 = 0 ;
24955 PyObject * obj0 = 0 ;
24956 PyObject * obj1 = 0 ;
24957 char * kwnames[] = {
24958 (char *) "self",(char *) "veto", NULL
24959 };
24960
24961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24963 if (!SWIG_IsOK(res1)) {
24964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24965 }
24966 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24967 if (obj1) {
24968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24969 if (!SWIG_IsOK(ecode2)) {
24970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24971 }
24972 arg2 = static_cast< bool >(val2);
24973 }
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 (arg1)->Veto(arg2);
24977 wxPyEndAllowThreads(__tstate);
24978 if (PyErr_Occurred()) SWIG_fail;
24979 }
24980 resultobj = SWIG_Py_Void();
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988 PyObject *resultobj = 0;
24989 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24990 bool result;
24991 void *argp1 = 0 ;
24992 int res1 = 0 ;
24993 PyObject *swig_obj[1] ;
24994
24995 if (!args) SWIG_fail;
24996 swig_obj[0] = args;
24997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25000 }
25001 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25002 {
25003 PyThreadState* __tstate = wxPyBeginAllowThreads();
25004 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25005 wxPyEndAllowThreads(__tstate);
25006 if (PyErr_Occurred()) SWIG_fail;
25007 }
25008 {
25009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25010 }
25011 return resultobj;
25012 fail:
25013 return NULL;
25014 }
25015
25016
25017 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25018 PyObject *resultobj = 0;
25019 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25020 bool arg2 ;
25021 void *argp1 = 0 ;
25022 int res1 = 0 ;
25023 bool val2 ;
25024 int ecode2 = 0 ;
25025 PyObject * obj0 = 0 ;
25026 PyObject * obj1 = 0 ;
25027 char * kwnames[] = {
25028 (char *) "self",(char *) "canVeto", NULL
25029 };
25030
25031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25033 if (!SWIG_IsOK(res1)) {
25034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25035 }
25036 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25037 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25038 if (!SWIG_IsOK(ecode2)) {
25039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25040 }
25041 arg2 = static_cast< bool >(val2);
25042 {
25043 PyThreadState* __tstate = wxPyBeginAllowThreads();
25044 (arg1)->SetCanVeto(arg2);
25045 wxPyEndAllowThreads(__tstate);
25046 if (PyErr_Occurred()) SWIG_fail;
25047 }
25048 resultobj = SWIG_Py_Void();
25049 return resultobj;
25050 fail:
25051 return NULL;
25052 }
25053
25054
25055 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25056 PyObject *resultobj = 0;
25057 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25058 bool result;
25059 void *argp1 = 0 ;
25060 int res1 = 0 ;
25061 PyObject *swig_obj[1] ;
25062
25063 if (!args) SWIG_fail;
25064 swig_obj[0] = args;
25065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25066 if (!SWIG_IsOK(res1)) {
25067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25068 }
25069 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 {
25077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25078 }
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25086 PyObject *obj;
25087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25088 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25089 return SWIG_Py_Void();
25090 }
25091
25092 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25093 return SWIG_Python_InitShadowInstance(args);
25094 }
25095
25096 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25097 PyObject *resultobj = 0;
25098 int arg1 = (int) 0 ;
25099 bool arg2 = (bool) false ;
25100 wxShowEvent *result = 0 ;
25101 int val1 ;
25102 int ecode1 = 0 ;
25103 bool val2 ;
25104 int ecode2 = 0 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 char * kwnames[] = {
25108 (char *) "winid",(char *) "show", NULL
25109 };
25110
25111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25112 if (obj0) {
25113 ecode1 = SWIG_AsVal_int(obj0, &val1);
25114 if (!SWIG_IsOK(ecode1)) {
25115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25116 }
25117 arg1 = static_cast< int >(val1);
25118 }
25119 if (obj1) {
25120 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25121 if (!SWIG_IsOK(ecode2)) {
25122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25123 }
25124 arg2 = static_cast< bool >(val2);
25125 }
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25140 PyObject *resultobj = 0;
25141 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25142 bool arg2 ;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 bool val2 ;
25146 int ecode2 = 0 ;
25147 PyObject * obj0 = 0 ;
25148 PyObject * obj1 = 0 ;
25149 char * kwnames[] = {
25150 (char *) "self",(char *) "show", NULL
25151 };
25152
25153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25155 if (!SWIG_IsOK(res1)) {
25156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25157 }
25158 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25159 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25160 if (!SWIG_IsOK(ecode2)) {
25161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25162 }
25163 arg2 = static_cast< bool >(val2);
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 (arg1)->SetShow(arg2);
25167 wxPyEndAllowThreads(__tstate);
25168 if (PyErr_Occurred()) SWIG_fail;
25169 }
25170 resultobj = SWIG_Py_Void();
25171 return resultobj;
25172 fail:
25173 return NULL;
25174 }
25175
25176
25177 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25178 PyObject *resultobj = 0;
25179 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25180 bool result;
25181 void *argp1 = 0 ;
25182 int res1 = 0 ;
25183 PyObject *swig_obj[1] ;
25184
25185 if (!args) SWIG_fail;
25186 swig_obj[0] = args;
25187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25188 if (!SWIG_IsOK(res1)) {
25189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25190 }
25191 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25192 {
25193 PyThreadState* __tstate = wxPyBeginAllowThreads();
25194 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25195 wxPyEndAllowThreads(__tstate);
25196 if (PyErr_Occurred()) SWIG_fail;
25197 }
25198 {
25199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25200 }
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25208 PyObject *obj;
25209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25210 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25211 return SWIG_Py_Void();
25212 }
25213
25214 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25215 return SWIG_Python_InitShadowInstance(args);
25216 }
25217
25218 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 int arg1 = (int) 0 ;
25221 bool arg2 = (bool) true ;
25222 wxIconizeEvent *result = 0 ;
25223 int val1 ;
25224 int ecode1 = 0 ;
25225 bool val2 ;
25226 int ecode2 = 0 ;
25227 PyObject * obj0 = 0 ;
25228 PyObject * obj1 = 0 ;
25229 char * kwnames[] = {
25230 (char *) "id",(char *) "iconized", NULL
25231 };
25232
25233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25234 if (obj0) {
25235 ecode1 = SWIG_AsVal_int(obj0, &val1);
25236 if (!SWIG_IsOK(ecode1)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25238 }
25239 arg1 = static_cast< int >(val1);
25240 }
25241 if (obj1) {
25242 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25243 if (!SWIG_IsOK(ecode2)) {
25244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25245 }
25246 arg2 = static_cast< bool >(val2);
25247 }
25248 {
25249 PyThreadState* __tstate = wxPyBeginAllowThreads();
25250 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25255 return resultobj;
25256 fail:
25257 return NULL;
25258 }
25259
25260
25261 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25262 PyObject *resultobj = 0;
25263 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25264 bool result;
25265 void *argp1 = 0 ;
25266 int res1 = 0 ;
25267 PyObject *swig_obj[1] ;
25268
25269 if (!args) SWIG_fail;
25270 swig_obj[0] = args;
25271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25274 }
25275 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25276 {
25277 PyThreadState* __tstate = wxPyBeginAllowThreads();
25278 result = (bool)(arg1)->Iconized();
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 {
25283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25284 }
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *obj;
25293 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25294 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25295 return SWIG_Py_Void();
25296 }
25297
25298 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25299 return SWIG_Python_InitShadowInstance(args);
25300 }
25301
25302 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25303 PyObject *resultobj = 0;
25304 int arg1 = (int) 0 ;
25305 wxMaximizeEvent *result = 0 ;
25306 int val1 ;
25307 int ecode1 = 0 ;
25308 PyObject * obj0 = 0 ;
25309 char * kwnames[] = {
25310 (char *) "id", NULL
25311 };
25312
25313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25314 if (obj0) {
25315 ecode1 = SWIG_AsVal_int(obj0, &val1);
25316 if (!SWIG_IsOK(ecode1)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25318 }
25319 arg1 = static_cast< int >(val1);
25320 }
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25324 wxPyEndAllowThreads(__tstate);
25325 if (PyErr_Occurred()) SWIG_fail;
25326 }
25327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25335 PyObject *obj;
25336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25337 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25338 return SWIG_Py_Void();
25339 }
25340
25341 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25342 return SWIG_Python_InitShadowInstance(args);
25343 }
25344
25345 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346 PyObject *resultobj = 0;
25347 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25348 wxPoint result;
25349 void *argp1 = 0 ;
25350 int res1 = 0 ;
25351 PyObject *swig_obj[1] ;
25352
25353 if (!args) SWIG_fail;
25354 swig_obj[0] = args;
25355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25356 if (!SWIG_IsOK(res1)) {
25357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25358 }
25359 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25360 {
25361 PyThreadState* __tstate = wxPyBeginAllowThreads();
25362 result = (arg1)->GetPosition();
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25374 PyObject *resultobj = 0;
25375 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25376 int result;
25377 void *argp1 = 0 ;
25378 int res1 = 0 ;
25379 PyObject *swig_obj[1] ;
25380
25381 if (!args) SWIG_fail;
25382 swig_obj[0] = args;
25383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25384 if (!SWIG_IsOK(res1)) {
25385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25386 }
25387 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25388 {
25389 PyThreadState* __tstate = wxPyBeginAllowThreads();
25390 result = (int)(arg1)->GetNumberOfFiles();
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 resultobj = SWIG_From_int(static_cast< int >(result));
25395 return resultobj;
25396 fail:
25397 return NULL;
25398 }
25399
25400
25401 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25402 PyObject *resultobj = 0;
25403 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25404 PyObject *result = 0 ;
25405 void *argp1 = 0 ;
25406 int res1 = 0 ;
25407 PyObject *swig_obj[1] ;
25408
25409 if (!args) SWIG_fail;
25410 swig_obj[0] = args;
25411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25412 if (!SWIG_IsOK(res1)) {
25413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25414 }
25415 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25416 {
25417 PyThreadState* __tstate = wxPyBeginAllowThreads();
25418 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 resultobj = result;
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *obj;
25431 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25432 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25433 return SWIG_Py_Void();
25434 }
25435
25436 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj = 0;
25438 int arg1 = (int) 0 ;
25439 wxUpdateUIEvent *result = 0 ;
25440 int val1 ;
25441 int ecode1 = 0 ;
25442 PyObject * obj0 = 0 ;
25443 char * kwnames[] = {
25444 (char *) "commandId", NULL
25445 };
25446
25447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25448 if (obj0) {
25449 ecode1 = SWIG_AsVal_int(obj0, &val1);
25450 if (!SWIG_IsOK(ecode1)) {
25451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25452 }
25453 arg1 = static_cast< int >(val1);
25454 }
25455 {
25456 PyThreadState* __tstate = wxPyBeginAllowThreads();
25457 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25458 wxPyEndAllowThreads(__tstate);
25459 if (PyErr_Occurred()) SWIG_fail;
25460 }
25461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25462 return resultobj;
25463 fail:
25464 return NULL;
25465 }
25466
25467
25468 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25469 PyObject *resultobj = 0;
25470 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25471 bool result;
25472 void *argp1 = 0 ;
25473 int res1 = 0 ;
25474 PyObject *swig_obj[1] ;
25475
25476 if (!args) SWIG_fail;
25477 swig_obj[0] = args;
25478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25479 if (!SWIG_IsOK(res1)) {
25480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25481 }
25482 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25483 {
25484 PyThreadState* __tstate = wxPyBeginAllowThreads();
25485 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25486 wxPyEndAllowThreads(__tstate);
25487 if (PyErr_Occurred()) SWIG_fail;
25488 }
25489 {
25490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25491 }
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25499 PyObject *resultobj = 0;
25500 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25501 bool result;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 PyObject *swig_obj[1] ;
25505
25506 if (!args) SWIG_fail;
25507 swig_obj[0] = args;
25508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25509 if (!SWIG_IsOK(res1)) {
25510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25511 }
25512 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25513 {
25514 PyThreadState* __tstate = wxPyBeginAllowThreads();
25515 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25516 wxPyEndAllowThreads(__tstate);
25517 if (PyErr_Occurred()) SWIG_fail;
25518 }
25519 {
25520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25521 }
25522 return resultobj;
25523 fail:
25524 return NULL;
25525 }
25526
25527
25528 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25529 PyObject *resultobj = 0;
25530 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25531 bool result;
25532 void *argp1 = 0 ;
25533 int res1 = 0 ;
25534 PyObject *swig_obj[1] ;
25535
25536 if (!args) SWIG_fail;
25537 swig_obj[0] = args;
25538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25539 if (!SWIG_IsOK(res1)) {
25540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25541 }
25542 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25543 {
25544 PyThreadState* __tstate = wxPyBeginAllowThreads();
25545 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25546 wxPyEndAllowThreads(__tstate);
25547 if (PyErr_Occurred()) SWIG_fail;
25548 }
25549 {
25550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25551 }
25552 return resultobj;
25553 fail:
25554 return NULL;
25555 }
25556
25557
25558 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25559 PyObject *resultobj = 0;
25560 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25561 wxString result;
25562 void *argp1 = 0 ;
25563 int res1 = 0 ;
25564 PyObject *swig_obj[1] ;
25565
25566 if (!args) SWIG_fail;
25567 swig_obj[0] = args;
25568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25569 if (!SWIG_IsOK(res1)) {
25570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25571 }
25572 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25576 wxPyEndAllowThreads(__tstate);
25577 if (PyErr_Occurred()) SWIG_fail;
25578 }
25579 {
25580 #if wxUSE_UNICODE
25581 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25582 #else
25583 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25584 #endif
25585 }
25586 return resultobj;
25587 fail:
25588 return NULL;
25589 }
25590
25591
25592 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25593 PyObject *resultobj = 0;
25594 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25595 bool result;
25596 void *argp1 = 0 ;
25597 int res1 = 0 ;
25598 PyObject *swig_obj[1] ;
25599
25600 if (!args) SWIG_fail;
25601 swig_obj[0] = args;
25602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25603 if (!SWIG_IsOK(res1)) {
25604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25605 }
25606 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25607 {
25608 PyThreadState* __tstate = wxPyBeginAllowThreads();
25609 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25610 wxPyEndAllowThreads(__tstate);
25611 if (PyErr_Occurred()) SWIG_fail;
25612 }
25613 {
25614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25615 }
25616 return resultobj;
25617 fail:
25618 return NULL;
25619 }
25620
25621
25622 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25623 PyObject *resultobj = 0;
25624 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25625 bool result;
25626 void *argp1 = 0 ;
25627 int res1 = 0 ;
25628 PyObject *swig_obj[1] ;
25629
25630 if (!args) SWIG_fail;
25631 swig_obj[0] = args;
25632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25633 if (!SWIG_IsOK(res1)) {
25634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25635 }
25636 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25637 {
25638 PyThreadState* __tstate = wxPyBeginAllowThreads();
25639 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25640 wxPyEndAllowThreads(__tstate);
25641 if (PyErr_Occurred()) SWIG_fail;
25642 }
25643 {
25644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25645 }
25646 return resultobj;
25647 fail:
25648 return NULL;
25649 }
25650
25651
25652 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25653 PyObject *resultobj = 0;
25654 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25655 bool result;
25656 void *argp1 = 0 ;
25657 int res1 = 0 ;
25658 PyObject *swig_obj[1] ;
25659
25660 if (!args) SWIG_fail;
25661 swig_obj[0] = args;
25662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25663 if (!SWIG_IsOK(res1)) {
25664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25665 }
25666 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25667 {
25668 PyThreadState* __tstate = wxPyBeginAllowThreads();
25669 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25670 wxPyEndAllowThreads(__tstate);
25671 if (PyErr_Occurred()) SWIG_fail;
25672 }
25673 {
25674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25675 }
25676 return resultobj;
25677 fail:
25678 return NULL;
25679 }
25680
25681
25682 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25683 PyObject *resultobj = 0;
25684 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25685 bool result;
25686 void *argp1 = 0 ;
25687 int res1 = 0 ;
25688 PyObject *swig_obj[1] ;
25689
25690 if (!args) SWIG_fail;
25691 swig_obj[0] = args;
25692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25693 if (!SWIG_IsOK(res1)) {
25694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25695 }
25696 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25697 {
25698 PyThreadState* __tstate = wxPyBeginAllowThreads();
25699 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 {
25704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25705 }
25706 return resultobj;
25707 fail:
25708 return NULL;
25709 }
25710
25711
25712 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25713 PyObject *resultobj = 0;
25714 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25715 bool arg2 ;
25716 void *argp1 = 0 ;
25717 int res1 = 0 ;
25718 bool val2 ;
25719 int ecode2 = 0 ;
25720 PyObject * obj0 = 0 ;
25721 PyObject * obj1 = 0 ;
25722 char * kwnames[] = {
25723 (char *) "self",(char *) "check", NULL
25724 };
25725
25726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25728 if (!SWIG_IsOK(res1)) {
25729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25730 }
25731 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25733 if (!SWIG_IsOK(ecode2)) {
25734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25735 }
25736 arg2 = static_cast< bool >(val2);
25737 {
25738 PyThreadState* __tstate = wxPyBeginAllowThreads();
25739 (arg1)->Check(arg2);
25740 wxPyEndAllowThreads(__tstate);
25741 if (PyErr_Occurred()) SWIG_fail;
25742 }
25743 resultobj = SWIG_Py_Void();
25744 return resultobj;
25745 fail:
25746 return NULL;
25747 }
25748
25749
25750 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25751 PyObject *resultobj = 0;
25752 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25753 bool arg2 ;
25754 void *argp1 = 0 ;
25755 int res1 = 0 ;
25756 bool val2 ;
25757 int ecode2 = 0 ;
25758 PyObject * obj0 = 0 ;
25759 PyObject * obj1 = 0 ;
25760 char * kwnames[] = {
25761 (char *) "self",(char *) "enable", NULL
25762 };
25763
25764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25766 if (!SWIG_IsOK(res1)) {
25767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25768 }
25769 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25771 if (!SWIG_IsOK(ecode2)) {
25772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25773 }
25774 arg2 = static_cast< bool >(val2);
25775 {
25776 PyThreadState* __tstate = wxPyBeginAllowThreads();
25777 (arg1)->Enable(arg2);
25778 wxPyEndAllowThreads(__tstate);
25779 if (PyErr_Occurred()) SWIG_fail;
25780 }
25781 resultobj = SWIG_Py_Void();
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj = 0;
25790 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25791 bool arg2 ;
25792 void *argp1 = 0 ;
25793 int res1 = 0 ;
25794 bool val2 ;
25795 int ecode2 = 0 ;
25796 PyObject * obj0 = 0 ;
25797 PyObject * obj1 = 0 ;
25798 char * kwnames[] = {
25799 (char *) "self",(char *) "show", NULL
25800 };
25801
25802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25804 if (!SWIG_IsOK(res1)) {
25805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25806 }
25807 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25809 if (!SWIG_IsOK(ecode2)) {
25810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25811 }
25812 arg2 = static_cast< bool >(val2);
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 (arg1)->Show(arg2);
25816 wxPyEndAllowThreads(__tstate);
25817 if (PyErr_Occurred()) SWIG_fail;
25818 }
25819 resultobj = SWIG_Py_Void();
25820 return resultobj;
25821 fail:
25822 return NULL;
25823 }
25824
25825
25826 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25827 PyObject *resultobj = 0;
25828 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25829 wxString *arg2 = 0 ;
25830 void *argp1 = 0 ;
25831 int res1 = 0 ;
25832 bool temp2 = false ;
25833 PyObject * obj0 = 0 ;
25834 PyObject * obj1 = 0 ;
25835 char * kwnames[] = {
25836 (char *) "self",(char *) "text", NULL
25837 };
25838
25839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25841 if (!SWIG_IsOK(res1)) {
25842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25843 }
25844 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25845 {
25846 arg2 = wxString_in_helper(obj1);
25847 if (arg2 == NULL) SWIG_fail;
25848 temp2 = true;
25849 }
25850 {
25851 PyThreadState* __tstate = wxPyBeginAllowThreads();
25852 (arg1)->SetText((wxString const &)*arg2);
25853 wxPyEndAllowThreads(__tstate);
25854 if (PyErr_Occurred()) SWIG_fail;
25855 }
25856 resultobj = SWIG_Py_Void();
25857 {
25858 if (temp2)
25859 delete arg2;
25860 }
25861 return resultobj;
25862 fail:
25863 {
25864 if (temp2)
25865 delete arg2;
25866 }
25867 return NULL;
25868 }
25869
25870
25871 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25872 PyObject *resultobj = 0;
25873 long arg1 ;
25874 long val1 ;
25875 int ecode1 = 0 ;
25876 PyObject * obj0 = 0 ;
25877 char * kwnames[] = {
25878 (char *) "updateInterval", NULL
25879 };
25880
25881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25882 ecode1 = SWIG_AsVal_long(obj0, &val1);
25883 if (!SWIG_IsOK(ecode1)) {
25884 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25885 }
25886 arg1 = static_cast< long >(val1);
25887 {
25888 PyThreadState* __tstate = wxPyBeginAllowThreads();
25889 wxUpdateUIEvent::SetUpdateInterval(arg1);
25890 wxPyEndAllowThreads(__tstate);
25891 if (PyErr_Occurred()) SWIG_fail;
25892 }
25893 resultobj = SWIG_Py_Void();
25894 return resultobj;
25895 fail:
25896 return NULL;
25897 }
25898
25899
25900 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25901 PyObject *resultobj = 0;
25902 long result;
25903
25904 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_From_long(static_cast< long >(result));
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25919 PyObject *resultobj = 0;
25920 wxWindow *arg1 = (wxWindow *) 0 ;
25921 bool result;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 PyObject * obj0 = 0 ;
25925 char * kwnames[] = {
25926 (char *) "win", NULL
25927 };
25928
25929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25931 if (!SWIG_IsOK(res1)) {
25932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25933 }
25934 arg1 = reinterpret_cast< wxWindow * >(argp1);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25943 }
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 PyObject *resultobj = 0;
25952
25953 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 wxUpdateUIEvent::ResetUpdateTime();
25957 wxPyEndAllowThreads(__tstate);
25958 if (PyErr_Occurred()) SWIG_fail;
25959 }
25960 resultobj = SWIG_Py_Void();
25961 return resultobj;
25962 fail:
25963 return NULL;
25964 }
25965
25966
25967 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25968 PyObject *resultobj = 0;
25969 wxUpdateUIMode arg1 ;
25970 int val1 ;
25971 int ecode1 = 0 ;
25972 PyObject * obj0 = 0 ;
25973 char * kwnames[] = {
25974 (char *) "mode", NULL
25975 };
25976
25977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25978 ecode1 = SWIG_AsVal_int(obj0, &val1);
25979 if (!SWIG_IsOK(ecode1)) {
25980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25981 }
25982 arg1 = static_cast< wxUpdateUIMode >(val1);
25983 {
25984 PyThreadState* __tstate = wxPyBeginAllowThreads();
25985 wxUpdateUIEvent::SetMode(arg1);
25986 wxPyEndAllowThreads(__tstate);
25987 if (PyErr_Occurred()) SWIG_fail;
25988 }
25989 resultobj = SWIG_Py_Void();
25990 return resultobj;
25991 fail:
25992 return NULL;
25993 }
25994
25995
25996 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25997 PyObject *resultobj = 0;
25998 wxUpdateUIMode result;
25999
26000 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 resultobj = SWIG_From_int(static_cast< int >(result));
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26015 PyObject *obj;
26016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26017 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26018 return SWIG_Py_Void();
26019 }
26020
26021 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26022 return SWIG_Python_InitShadowInstance(args);
26023 }
26024
26025 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26026 PyObject *resultobj = 0;
26027 wxSysColourChangedEvent *result = 0 ;
26028
26029 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26033 wxPyEndAllowThreads(__tstate);
26034 if (PyErr_Occurred()) SWIG_fail;
26035 }
26036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26037 return resultobj;
26038 fail:
26039 return NULL;
26040 }
26041
26042
26043 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26044 PyObject *obj;
26045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26046 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26047 return SWIG_Py_Void();
26048 }
26049
26050 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26051 return SWIG_Python_InitShadowInstance(args);
26052 }
26053
26054 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26055 PyObject *resultobj = 0;
26056 int arg1 = (int) 0 ;
26057 wxWindow *arg2 = (wxWindow *) NULL ;
26058 wxMouseCaptureChangedEvent *result = 0 ;
26059 int val1 ;
26060 int ecode1 = 0 ;
26061 void *argp2 = 0 ;
26062 int res2 = 0 ;
26063 PyObject * obj0 = 0 ;
26064 PyObject * obj1 = 0 ;
26065 char * kwnames[] = {
26066 (char *) "winid",(char *) "gainedCapture", NULL
26067 };
26068
26069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26070 if (obj0) {
26071 ecode1 = SWIG_AsVal_int(obj0, &val1);
26072 if (!SWIG_IsOK(ecode1)) {
26073 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26074 }
26075 arg1 = static_cast< int >(val1);
26076 }
26077 if (obj1) {
26078 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26079 if (!SWIG_IsOK(res2)) {
26080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26081 }
26082 arg2 = reinterpret_cast< wxWindow * >(argp2);
26083 }
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26087 wxPyEndAllowThreads(__tstate);
26088 if (PyErr_Occurred()) SWIG_fail;
26089 }
26090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26091 return resultobj;
26092 fail:
26093 return NULL;
26094 }
26095
26096
26097 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26098 PyObject *resultobj = 0;
26099 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26100 wxWindow *result = 0 ;
26101 void *argp1 = 0 ;
26102 int res1 = 0 ;
26103 PyObject *swig_obj[1] ;
26104
26105 if (!args) SWIG_fail;
26106 swig_obj[0] = args;
26107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26108 if (!SWIG_IsOK(res1)) {
26109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26110 }
26111 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26115 wxPyEndAllowThreads(__tstate);
26116 if (PyErr_Occurred()) SWIG_fail;
26117 }
26118 {
26119 resultobj = wxPyMake_wxObject(result, (bool)0);
26120 }
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26128 PyObject *obj;
26129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26130 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26131 return SWIG_Py_Void();
26132 }
26133
26134 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26135 return SWIG_Python_InitShadowInstance(args);
26136 }
26137
26138 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26139 PyObject *resultobj = 0;
26140 int arg1 = (int) 0 ;
26141 wxMouseCaptureLostEvent *result = 0 ;
26142 int val1 ;
26143 int ecode1 = 0 ;
26144 PyObject * obj0 = 0 ;
26145 char * kwnames[] = {
26146 (char *) "winid", NULL
26147 };
26148
26149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26150 if (obj0) {
26151 ecode1 = SWIG_AsVal_int(obj0, &val1);
26152 if (!SWIG_IsOK(ecode1)) {
26153 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26154 }
26155 arg1 = static_cast< int >(val1);
26156 }
26157 {
26158 PyThreadState* __tstate = wxPyBeginAllowThreads();
26159 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26171 PyObject *obj;
26172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26173 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26174 return SWIG_Py_Void();
26175 }
26176
26177 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26178 return SWIG_Python_InitShadowInstance(args);
26179 }
26180
26181 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26182 PyObject *resultobj = 0;
26183 wxDisplayChangedEvent *result = 0 ;
26184
26185 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26193 return resultobj;
26194 fail:
26195 return NULL;
26196 }
26197
26198
26199 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26200 PyObject *obj;
26201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26202 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26203 return SWIG_Py_Void();
26204 }
26205
26206 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26207 return SWIG_Python_InitShadowInstance(args);
26208 }
26209
26210 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26211 PyObject *resultobj = 0;
26212 int arg1 = (int) 0 ;
26213 wxPaletteChangedEvent *result = 0 ;
26214 int val1 ;
26215 int ecode1 = 0 ;
26216 PyObject * obj0 = 0 ;
26217 char * kwnames[] = {
26218 (char *) "id", NULL
26219 };
26220
26221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26222 if (obj0) {
26223 ecode1 = SWIG_AsVal_int(obj0, &val1);
26224 if (!SWIG_IsOK(ecode1)) {
26225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26226 }
26227 arg1 = static_cast< int >(val1);
26228 }
26229 {
26230 PyThreadState* __tstate = wxPyBeginAllowThreads();
26231 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = 0;
26244 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26245 wxWindow *arg2 = (wxWindow *) 0 ;
26246 void *argp1 = 0 ;
26247 int res1 = 0 ;
26248 void *argp2 = 0 ;
26249 int res2 = 0 ;
26250 PyObject * obj0 = 0 ;
26251 PyObject * obj1 = 0 ;
26252 char * kwnames[] = {
26253 (char *) "self",(char *) "win", NULL
26254 };
26255
26256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26258 if (!SWIG_IsOK(res1)) {
26259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26260 }
26261 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26263 if (!SWIG_IsOK(res2)) {
26264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26265 }
26266 arg2 = reinterpret_cast< wxWindow * >(argp2);
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 (arg1)->SetChangedWindow(arg2);
26270 wxPyEndAllowThreads(__tstate);
26271 if (PyErr_Occurred()) SWIG_fail;
26272 }
26273 resultobj = SWIG_Py_Void();
26274 return resultobj;
26275 fail:
26276 return NULL;
26277 }
26278
26279
26280 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26281 PyObject *resultobj = 0;
26282 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26283 wxWindow *result = 0 ;
26284 void *argp1 = 0 ;
26285 int res1 = 0 ;
26286 PyObject *swig_obj[1] ;
26287
26288 if (!args) SWIG_fail;
26289 swig_obj[0] = args;
26290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26291 if (!SWIG_IsOK(res1)) {
26292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26293 }
26294 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26295 {
26296 PyThreadState* __tstate = wxPyBeginAllowThreads();
26297 result = (wxWindow *)(arg1)->GetChangedWindow();
26298 wxPyEndAllowThreads(__tstate);
26299 if (PyErr_Occurred()) SWIG_fail;
26300 }
26301 {
26302 resultobj = wxPyMake_wxObject(result, (bool)0);
26303 }
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26311 PyObject *obj;
26312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26313 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26314 return SWIG_Py_Void();
26315 }
26316
26317 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26318 return SWIG_Python_InitShadowInstance(args);
26319 }
26320
26321 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26322 PyObject *resultobj = 0;
26323 int arg1 = (int) 0 ;
26324 wxQueryNewPaletteEvent *result = 0 ;
26325 int val1 ;
26326 int ecode1 = 0 ;
26327 PyObject * obj0 = 0 ;
26328 char * kwnames[] = {
26329 (char *) "winid", NULL
26330 };
26331
26332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26333 if (obj0) {
26334 ecode1 = SWIG_AsVal_int(obj0, &val1);
26335 if (!SWIG_IsOK(ecode1)) {
26336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26337 }
26338 arg1 = static_cast< int >(val1);
26339 }
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj = 0;
26355 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26356 bool arg2 ;
26357 void *argp1 = 0 ;
26358 int res1 = 0 ;
26359 bool val2 ;
26360 int ecode2 = 0 ;
26361 PyObject * obj0 = 0 ;
26362 PyObject * obj1 = 0 ;
26363 char * kwnames[] = {
26364 (char *) "self",(char *) "realized", NULL
26365 };
26366
26367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26369 if (!SWIG_IsOK(res1)) {
26370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26371 }
26372 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26374 if (!SWIG_IsOK(ecode2)) {
26375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26376 }
26377 arg2 = static_cast< bool >(val2);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 (arg1)->SetPaletteRealized(arg2);
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 resultobj = SWIG_Py_Void();
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26392 PyObject *resultobj = 0;
26393 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26394 bool result;
26395 void *argp1 = 0 ;
26396 int res1 = 0 ;
26397 PyObject *swig_obj[1] ;
26398
26399 if (!args) SWIG_fail;
26400 swig_obj[0] = args;
26401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26402 if (!SWIG_IsOK(res1)) {
26403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26404 }
26405 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26406 {
26407 PyThreadState* __tstate = wxPyBeginAllowThreads();
26408 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 {
26413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *obj;
26423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26424 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26425 return SWIG_Py_Void();
26426 }
26427
26428 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26429 return SWIG_Python_InitShadowInstance(args);
26430 }
26431
26432 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26433 PyObject *resultobj = 0;
26434 wxNavigationKeyEvent *result = 0 ;
26435
26436 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26437 {
26438 PyThreadState* __tstate = wxPyBeginAllowThreads();
26439 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26440 wxPyEndAllowThreads(__tstate);
26441 if (PyErr_Occurred()) SWIG_fail;
26442 }
26443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26451 PyObject *resultobj = 0;
26452 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26453 bool result;
26454 void *argp1 = 0 ;
26455 int res1 = 0 ;
26456 PyObject *swig_obj[1] ;
26457
26458 if (!args) SWIG_fail;
26459 swig_obj[0] = args;
26460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26461 if (!SWIG_IsOK(res1)) {
26462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26463 }
26464 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26465 {
26466 PyThreadState* __tstate = wxPyBeginAllowThreads();
26467 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 {
26472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26473 }
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj = 0;
26482 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26483 bool arg2 ;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 bool val2 ;
26487 int ecode2 = 0 ;
26488 PyObject * obj0 = 0 ;
26489 PyObject * obj1 = 0 ;
26490 char * kwnames[] = {
26491 (char *) "self",(char *) "forward", NULL
26492 };
26493
26494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26496 if (!SWIG_IsOK(res1)) {
26497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26498 }
26499 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26500 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26501 if (!SWIG_IsOK(ecode2)) {
26502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26503 }
26504 arg2 = static_cast< bool >(val2);
26505 {
26506 PyThreadState* __tstate = wxPyBeginAllowThreads();
26507 (arg1)->SetDirection(arg2);
26508 wxPyEndAllowThreads(__tstate);
26509 if (PyErr_Occurred()) SWIG_fail;
26510 }
26511 resultobj = SWIG_Py_Void();
26512 return resultobj;
26513 fail:
26514 return NULL;
26515 }
26516
26517
26518 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26519 PyObject *resultobj = 0;
26520 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26521 bool result;
26522 void *argp1 = 0 ;
26523 int res1 = 0 ;
26524 PyObject *swig_obj[1] ;
26525
26526 if (!args) SWIG_fail;
26527 swig_obj[0] = args;
26528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26529 if (!SWIG_IsOK(res1)) {
26530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26531 }
26532 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26533 {
26534 PyThreadState* __tstate = wxPyBeginAllowThreads();
26535 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 {
26540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26541 }
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26549 PyObject *resultobj = 0;
26550 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26551 bool arg2 ;
26552 void *argp1 = 0 ;
26553 int res1 = 0 ;
26554 bool val2 ;
26555 int ecode2 = 0 ;
26556 PyObject * obj0 = 0 ;
26557 PyObject * obj1 = 0 ;
26558 char * kwnames[] = {
26559 (char *) "self",(char *) "ischange", NULL
26560 };
26561
26562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26564 if (!SWIG_IsOK(res1)) {
26565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26566 }
26567 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26568 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26569 if (!SWIG_IsOK(ecode2)) {
26570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26571 }
26572 arg2 = static_cast< bool >(val2);
26573 {
26574 PyThreadState* __tstate = wxPyBeginAllowThreads();
26575 (arg1)->SetWindowChange(arg2);
26576 wxPyEndAllowThreads(__tstate);
26577 if (PyErr_Occurred()) SWIG_fail;
26578 }
26579 resultobj = SWIG_Py_Void();
26580 return resultobj;
26581 fail:
26582 return NULL;
26583 }
26584
26585
26586 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26587 PyObject *resultobj = 0;
26588 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26589 bool result;
26590 void *argp1 = 0 ;
26591 int res1 = 0 ;
26592 PyObject *swig_obj[1] ;
26593
26594 if (!args) SWIG_fail;
26595 swig_obj[0] = args;
26596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26597 if (!SWIG_IsOK(res1)) {
26598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26599 }
26600 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26601 {
26602 PyThreadState* __tstate = wxPyBeginAllowThreads();
26603 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26604 wxPyEndAllowThreads(__tstate);
26605 if (PyErr_Occurred()) SWIG_fail;
26606 }
26607 {
26608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26609 }
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj = 0;
26618 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26619 bool arg2 ;
26620 void *argp1 = 0 ;
26621 int res1 = 0 ;
26622 bool val2 ;
26623 int ecode2 = 0 ;
26624 PyObject * obj0 = 0 ;
26625 PyObject * obj1 = 0 ;
26626 char * kwnames[] = {
26627 (char *) "self",(char *) "bIs", NULL
26628 };
26629
26630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26632 if (!SWIG_IsOK(res1)) {
26633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26634 }
26635 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26636 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26637 if (!SWIG_IsOK(ecode2)) {
26638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26639 }
26640 arg2 = static_cast< bool >(val2);
26641 {
26642 PyThreadState* __tstate = wxPyBeginAllowThreads();
26643 (arg1)->SetFromTab(arg2);
26644 wxPyEndAllowThreads(__tstate);
26645 if (PyErr_Occurred()) SWIG_fail;
26646 }
26647 resultobj = SWIG_Py_Void();
26648 return resultobj;
26649 fail:
26650 return NULL;
26651 }
26652
26653
26654 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26655 PyObject *resultobj = 0;
26656 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26657 long arg2 ;
26658 void *argp1 = 0 ;
26659 int res1 = 0 ;
26660 long val2 ;
26661 int ecode2 = 0 ;
26662 PyObject * obj0 = 0 ;
26663 PyObject * obj1 = 0 ;
26664 char * kwnames[] = {
26665 (char *) "self",(char *) "flags", NULL
26666 };
26667
26668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26670 if (!SWIG_IsOK(res1)) {
26671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26672 }
26673 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26674 ecode2 = SWIG_AsVal_long(obj1, &val2);
26675 if (!SWIG_IsOK(ecode2)) {
26676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26677 }
26678 arg2 = static_cast< long >(val2);
26679 {
26680 PyThreadState* __tstate = wxPyBeginAllowThreads();
26681 (arg1)->SetFlags(arg2);
26682 wxPyEndAllowThreads(__tstate);
26683 if (PyErr_Occurred()) SWIG_fail;
26684 }
26685 resultobj = SWIG_Py_Void();
26686 return resultobj;
26687 fail:
26688 return NULL;
26689 }
26690
26691
26692 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26693 PyObject *resultobj = 0;
26694 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26695 wxWindow *result = 0 ;
26696 void *argp1 = 0 ;
26697 int res1 = 0 ;
26698 PyObject *swig_obj[1] ;
26699
26700 if (!args) SWIG_fail;
26701 swig_obj[0] = args;
26702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26703 if (!SWIG_IsOK(res1)) {
26704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26705 }
26706 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26707 {
26708 PyThreadState* __tstate = wxPyBeginAllowThreads();
26709 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 {
26714 resultobj = wxPyMake_wxObject(result, (bool)0);
26715 }
26716 return resultobj;
26717 fail:
26718 return NULL;
26719 }
26720
26721
26722 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26723 PyObject *resultobj = 0;
26724 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26725 wxWindow *arg2 = (wxWindow *) 0 ;
26726 void *argp1 = 0 ;
26727 int res1 = 0 ;
26728 void *argp2 = 0 ;
26729 int res2 = 0 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 char * kwnames[] = {
26733 (char *) "self",(char *) "win", NULL
26734 };
26735
26736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26738 if (!SWIG_IsOK(res1)) {
26739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26740 }
26741 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26742 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26743 if (!SWIG_IsOK(res2)) {
26744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26745 }
26746 arg2 = reinterpret_cast< wxWindow * >(argp2);
26747 {
26748 PyThreadState* __tstate = wxPyBeginAllowThreads();
26749 (arg1)->SetCurrentFocus(arg2);
26750 wxPyEndAllowThreads(__tstate);
26751 if (PyErr_Occurred()) SWIG_fail;
26752 }
26753 resultobj = SWIG_Py_Void();
26754 return resultobj;
26755 fail:
26756 return NULL;
26757 }
26758
26759
26760 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26761 PyObject *obj;
26762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26763 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26764 return SWIG_Py_Void();
26765 }
26766
26767 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26768 return SWIG_Python_InitShadowInstance(args);
26769 }
26770
26771 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26772 PyObject *resultobj = 0;
26773 wxWindow *arg1 = (wxWindow *) NULL ;
26774 wxWindowCreateEvent *result = 0 ;
26775 void *argp1 = 0 ;
26776 int res1 = 0 ;
26777 PyObject * obj0 = 0 ;
26778 char * kwnames[] = {
26779 (char *) "win", NULL
26780 };
26781
26782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26783 if (obj0) {
26784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26785 if (!SWIG_IsOK(res1)) {
26786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26787 }
26788 arg1 = reinterpret_cast< wxWindow * >(argp1);
26789 }
26790 {
26791 PyThreadState* __tstate = wxPyBeginAllowThreads();
26792 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26793 wxPyEndAllowThreads(__tstate);
26794 if (PyErr_Occurred()) SWIG_fail;
26795 }
26796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26797 return resultobj;
26798 fail:
26799 return NULL;
26800 }
26801
26802
26803 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26804 PyObject *resultobj = 0;
26805 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26806 wxWindow *result = 0 ;
26807 void *argp1 = 0 ;
26808 int res1 = 0 ;
26809 PyObject *swig_obj[1] ;
26810
26811 if (!args) SWIG_fail;
26812 swig_obj[0] = args;
26813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26814 if (!SWIG_IsOK(res1)) {
26815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26816 }
26817 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26818 {
26819 PyThreadState* __tstate = wxPyBeginAllowThreads();
26820 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 {
26825 resultobj = wxPyMake_wxObject(result, (bool)0);
26826 }
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26834 PyObject *obj;
26835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26836 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26837 return SWIG_Py_Void();
26838 }
26839
26840 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26841 return SWIG_Python_InitShadowInstance(args);
26842 }
26843
26844 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxWindow *arg1 = (wxWindow *) NULL ;
26847 wxWindowDestroyEvent *result = 0 ;
26848 void *argp1 = 0 ;
26849 int res1 = 0 ;
26850 PyObject * obj0 = 0 ;
26851 char * kwnames[] = {
26852 (char *) "win", NULL
26853 };
26854
26855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26856 if (obj0) {
26857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26858 if (!SWIG_IsOK(res1)) {
26859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26860 }
26861 arg1 = reinterpret_cast< wxWindow * >(argp1);
26862 }
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26866 wxPyEndAllowThreads(__tstate);
26867 if (PyErr_Occurred()) SWIG_fail;
26868 }
26869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26870 return resultobj;
26871 fail:
26872 return NULL;
26873 }
26874
26875
26876 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26877 PyObject *resultobj = 0;
26878 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26879 wxWindow *result = 0 ;
26880 void *argp1 = 0 ;
26881 int res1 = 0 ;
26882 PyObject *swig_obj[1] ;
26883
26884 if (!args) SWIG_fail;
26885 swig_obj[0] = args;
26886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26887 if (!SWIG_IsOK(res1)) {
26888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26889 }
26890 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26891 {
26892 PyThreadState* __tstate = wxPyBeginAllowThreads();
26893 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26894 wxPyEndAllowThreads(__tstate);
26895 if (PyErr_Occurred()) SWIG_fail;
26896 }
26897 {
26898 resultobj = wxPyMake_wxObject(result, (bool)0);
26899 }
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26907 PyObject *obj;
26908 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26909 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26910 return SWIG_Py_Void();
26911 }
26912
26913 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26914 return SWIG_Python_InitShadowInstance(args);
26915 }
26916
26917 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj = 0;
26919 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26920 int arg2 = (int) 0 ;
26921 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26922 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26923 wxContextMenuEvent *result = 0 ;
26924 int val1 ;
26925 int ecode1 = 0 ;
26926 int val2 ;
26927 int ecode2 = 0 ;
26928 wxPoint temp3 ;
26929 PyObject * obj0 = 0 ;
26930 PyObject * obj1 = 0 ;
26931 PyObject * obj2 = 0 ;
26932 char * kwnames[] = {
26933 (char *) "type",(char *) "winid",(char *) "pt", NULL
26934 };
26935
26936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26937 if (obj0) {
26938 ecode1 = SWIG_AsVal_int(obj0, &val1);
26939 if (!SWIG_IsOK(ecode1)) {
26940 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26941 }
26942 arg1 = static_cast< wxEventType >(val1);
26943 }
26944 if (obj1) {
26945 ecode2 = SWIG_AsVal_int(obj1, &val2);
26946 if (!SWIG_IsOK(ecode2)) {
26947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26948 }
26949 arg2 = static_cast< int >(val2);
26950 }
26951 if (obj2) {
26952 {
26953 arg3 = &temp3;
26954 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26955 }
26956 }
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26964 return resultobj;
26965 fail:
26966 return NULL;
26967 }
26968
26969
26970 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26971 PyObject *resultobj = 0;
26972 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26973 wxPoint *result = 0 ;
26974 void *argp1 = 0 ;
26975 int res1 = 0 ;
26976 PyObject *swig_obj[1] ;
26977
26978 if (!args) SWIG_fail;
26979 swig_obj[0] = args;
26980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26981 if (!SWIG_IsOK(res1)) {
26982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26983 }
26984 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26985 {
26986 PyThreadState* __tstate = wxPyBeginAllowThreads();
26987 {
26988 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26989 result = (wxPoint *) &_result_ref;
26990 }
26991 wxPyEndAllowThreads(__tstate);
26992 if (PyErr_Occurred()) SWIG_fail;
26993 }
26994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj = 0;
27003 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27004 wxPoint *arg2 = 0 ;
27005 void *argp1 = 0 ;
27006 int res1 = 0 ;
27007 wxPoint temp2 ;
27008 PyObject * obj0 = 0 ;
27009 PyObject * obj1 = 0 ;
27010 char * kwnames[] = {
27011 (char *) "self",(char *) "pos", NULL
27012 };
27013
27014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27016 if (!SWIG_IsOK(res1)) {
27017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27018 }
27019 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27020 {
27021 arg2 = &temp2;
27022 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27023 }
27024 {
27025 PyThreadState* __tstate = wxPyBeginAllowThreads();
27026 (arg1)->SetPosition((wxPoint const &)*arg2);
27027 wxPyEndAllowThreads(__tstate);
27028 if (PyErr_Occurred()) SWIG_fail;
27029 }
27030 resultobj = SWIG_Py_Void();
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27038 PyObject *obj;
27039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27040 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27041 return SWIG_Py_Void();
27042 }
27043
27044 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27045 return SWIG_Python_InitShadowInstance(args);
27046 }
27047
27048 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27049 PyObject *resultobj = 0;
27050 wxIdleEvent *result = 0 ;
27051
27052 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27053 {
27054 PyThreadState* __tstate = wxPyBeginAllowThreads();
27055 result = (wxIdleEvent *)new wxIdleEvent();
27056 wxPyEndAllowThreads(__tstate);
27057 if (PyErr_Occurred()) SWIG_fail;
27058 }
27059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj = 0;
27068 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27069 bool arg2 = (bool) true ;
27070 void *argp1 = 0 ;
27071 int res1 = 0 ;
27072 bool val2 ;
27073 int ecode2 = 0 ;
27074 PyObject * obj0 = 0 ;
27075 PyObject * obj1 = 0 ;
27076 char * kwnames[] = {
27077 (char *) "self",(char *) "needMore", NULL
27078 };
27079
27080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27082 if (!SWIG_IsOK(res1)) {
27083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27084 }
27085 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27086 if (obj1) {
27087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27088 if (!SWIG_IsOK(ecode2)) {
27089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27090 }
27091 arg2 = static_cast< bool >(val2);
27092 }
27093 {
27094 PyThreadState* __tstate = wxPyBeginAllowThreads();
27095 (arg1)->RequestMore(arg2);
27096 wxPyEndAllowThreads(__tstate);
27097 if (PyErr_Occurred()) SWIG_fail;
27098 }
27099 resultobj = SWIG_Py_Void();
27100 return resultobj;
27101 fail:
27102 return NULL;
27103 }
27104
27105
27106 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27107 PyObject *resultobj = 0;
27108 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27109 bool result;
27110 void *argp1 = 0 ;
27111 int res1 = 0 ;
27112 PyObject *swig_obj[1] ;
27113
27114 if (!args) SWIG_fail;
27115 swig_obj[0] = args;
27116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27117 if (!SWIG_IsOK(res1)) {
27118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27119 }
27120 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 {
27128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27129 }
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27137 PyObject *resultobj = 0;
27138 wxIdleMode arg1 ;
27139 int val1 ;
27140 int ecode1 = 0 ;
27141 PyObject * obj0 = 0 ;
27142 char * kwnames[] = {
27143 (char *) "mode", NULL
27144 };
27145
27146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27147 ecode1 = SWIG_AsVal_int(obj0, &val1);
27148 if (!SWIG_IsOK(ecode1)) {
27149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27150 }
27151 arg1 = static_cast< wxIdleMode >(val1);
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 wxIdleEvent::SetMode(arg1);
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 resultobj = SWIG_Py_Void();
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27166 PyObject *resultobj = 0;
27167 wxIdleMode result;
27168
27169 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = (wxIdleMode)wxIdleEvent::GetMode();
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 resultobj = SWIG_From_int(static_cast< int >(result));
27177 return resultobj;
27178 fail:
27179 return NULL;
27180 }
27181
27182
27183 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27184 PyObject *resultobj = 0;
27185 wxWindow *arg1 = (wxWindow *) 0 ;
27186 bool result;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 PyObject * obj0 = 0 ;
27190 char * kwnames[] = {
27191 (char *) "win", NULL
27192 };
27193
27194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27196 if (!SWIG_IsOK(res1)) {
27197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27198 }
27199 arg1 = reinterpret_cast< wxWindow * >(argp1);
27200 {
27201 PyThreadState* __tstate = wxPyBeginAllowThreads();
27202 result = (bool)wxIdleEvent::CanSend(arg1);
27203 wxPyEndAllowThreads(__tstate);
27204 if (PyErr_Occurred()) SWIG_fail;
27205 }
27206 {
27207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27208 }
27209 return resultobj;
27210 fail:
27211 return NULL;
27212 }
27213
27214
27215 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27216 PyObject *obj;
27217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27218 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27219 return SWIG_Py_Void();
27220 }
27221
27222 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27223 return SWIG_Python_InitShadowInstance(args);
27224 }
27225
27226 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27227 PyObject *resultobj = 0;
27228 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27229 int arg2 = (int) 0 ;
27230 wxClipboardTextEvent *result = 0 ;
27231 int val1 ;
27232 int ecode1 = 0 ;
27233 int val2 ;
27234 int ecode2 = 0 ;
27235 PyObject * obj0 = 0 ;
27236 PyObject * obj1 = 0 ;
27237 char * kwnames[] = {
27238 (char *) "type",(char *) "winid", NULL
27239 };
27240
27241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27242 if (obj0) {
27243 ecode1 = SWIG_AsVal_int(obj0, &val1);
27244 if (!SWIG_IsOK(ecode1)) {
27245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27246 }
27247 arg1 = static_cast< wxEventType >(val1);
27248 }
27249 if (obj1) {
27250 ecode2 = SWIG_AsVal_int(obj1, &val2);
27251 if (!SWIG_IsOK(ecode2)) {
27252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27253 }
27254 arg2 = static_cast< int >(val2);
27255 }
27256 {
27257 PyThreadState* __tstate = wxPyBeginAllowThreads();
27258 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27259 wxPyEndAllowThreads(__tstate);
27260 if (PyErr_Occurred()) SWIG_fail;
27261 }
27262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27270 PyObject *obj;
27271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27272 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27273 return SWIG_Py_Void();
27274 }
27275
27276 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27277 return SWIG_Python_InitShadowInstance(args);
27278 }
27279
27280 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27281 PyObject *resultobj = 0;
27282 int arg1 = (int) 0 ;
27283 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27284 wxPyEvent *result = 0 ;
27285 int val1 ;
27286 int ecode1 = 0 ;
27287 int val2 ;
27288 int ecode2 = 0 ;
27289 PyObject * obj0 = 0 ;
27290 PyObject * obj1 = 0 ;
27291 char * kwnames[] = {
27292 (char *) "winid",(char *) "eventType", NULL
27293 };
27294
27295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27296 if (obj0) {
27297 ecode1 = SWIG_AsVal_int(obj0, &val1);
27298 if (!SWIG_IsOK(ecode1)) {
27299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27300 }
27301 arg1 = static_cast< int >(val1);
27302 }
27303 if (obj1) {
27304 ecode2 = SWIG_AsVal_int(obj1, &val2);
27305 if (!SWIG_IsOK(ecode2)) {
27306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27307 }
27308 arg2 = static_cast< wxEventType >(val2);
27309 }
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27317 return resultobj;
27318 fail:
27319 return NULL;
27320 }
27321
27322
27323 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27324 PyObject *resultobj = 0;
27325 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27326 void *argp1 = 0 ;
27327 int res1 = 0 ;
27328 PyObject *swig_obj[1] ;
27329
27330 if (!args) SWIG_fail;
27331 swig_obj[0] = args;
27332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27333 if (!SWIG_IsOK(res1)) {
27334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27335 }
27336 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 delete arg1;
27340
27341 wxPyEndAllowThreads(__tstate);
27342 if (PyErr_Occurred()) SWIG_fail;
27343 }
27344 resultobj = SWIG_Py_Void();
27345 return resultobj;
27346 fail:
27347 return NULL;
27348 }
27349
27350
27351 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27352 PyObject *resultobj = 0;
27353 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27354 PyObject *arg2 = (PyObject *) 0 ;
27355 void *argp1 = 0 ;
27356 int res1 = 0 ;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 char * kwnames[] = {
27360 (char *) "self",(char *) "self", NULL
27361 };
27362
27363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27367 }
27368 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27369 arg2 = obj1;
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 (arg1)->SetSelf(arg2);
27373 wxPyEndAllowThreads(__tstate);
27374 if (PyErr_Occurred()) SWIG_fail;
27375 }
27376 resultobj = SWIG_Py_Void();
27377 return resultobj;
27378 fail:
27379 return NULL;
27380 }
27381
27382
27383 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27384 PyObject *resultobj = 0;
27385 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27386 PyObject *result = 0 ;
27387 void *argp1 = 0 ;
27388 int res1 = 0 ;
27389 PyObject *swig_obj[1] ;
27390
27391 if (!args) SWIG_fail;
27392 swig_obj[0] = args;
27393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27394 if (!SWIG_IsOK(res1)) {
27395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27396 }
27397 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = (PyObject *)(arg1)->GetSelf();
27401 wxPyEndAllowThreads(__tstate);
27402 if (PyErr_Occurred()) SWIG_fail;
27403 }
27404 resultobj = result;
27405 return resultobj;
27406 fail:
27407 return NULL;
27408 }
27409
27410
27411 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27412 PyObject *obj;
27413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27414 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27415 return SWIG_Py_Void();
27416 }
27417
27418 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27419 return SWIG_Python_InitShadowInstance(args);
27420 }
27421
27422 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27423 PyObject *resultobj = 0;
27424 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27425 int arg2 = (int) 0 ;
27426 wxPyCommandEvent *result = 0 ;
27427 int val1 ;
27428 int ecode1 = 0 ;
27429 int val2 ;
27430 int ecode2 = 0 ;
27431 PyObject * obj0 = 0 ;
27432 PyObject * obj1 = 0 ;
27433 char * kwnames[] = {
27434 (char *) "eventType",(char *) "id", NULL
27435 };
27436
27437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27438 if (obj0) {
27439 ecode1 = SWIG_AsVal_int(obj0, &val1);
27440 if (!SWIG_IsOK(ecode1)) {
27441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27442 }
27443 arg1 = static_cast< wxEventType >(val1);
27444 }
27445 if (obj1) {
27446 ecode2 = SWIG_AsVal_int(obj1, &val2);
27447 if (!SWIG_IsOK(ecode2)) {
27448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27449 }
27450 arg2 = static_cast< int >(val2);
27451 }
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27459 return resultobj;
27460 fail:
27461 return NULL;
27462 }
27463
27464
27465 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27466 PyObject *resultobj = 0;
27467 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27468 void *argp1 = 0 ;
27469 int res1 = 0 ;
27470 PyObject *swig_obj[1] ;
27471
27472 if (!args) SWIG_fail;
27473 swig_obj[0] = args;
27474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27475 if (!SWIG_IsOK(res1)) {
27476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27477 }
27478 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 delete arg1;
27482
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 resultobj = SWIG_Py_Void();
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj = 0;
27495 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27496 PyObject *arg2 = (PyObject *) 0 ;
27497 void *argp1 = 0 ;
27498 int res1 = 0 ;
27499 PyObject * obj0 = 0 ;
27500 PyObject * obj1 = 0 ;
27501 char * kwnames[] = {
27502 (char *) "self",(char *) "self", NULL
27503 };
27504
27505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27509 }
27510 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27511 arg2 = obj1;
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 (arg1)->SetSelf(arg2);
27515 wxPyEndAllowThreads(__tstate);
27516 if (PyErr_Occurred()) SWIG_fail;
27517 }
27518 resultobj = SWIG_Py_Void();
27519 return resultobj;
27520 fail:
27521 return NULL;
27522 }
27523
27524
27525 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27526 PyObject *resultobj = 0;
27527 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27528 PyObject *result = 0 ;
27529 void *argp1 = 0 ;
27530 int res1 = 0 ;
27531 PyObject *swig_obj[1] ;
27532
27533 if (!args) SWIG_fail;
27534 swig_obj[0] = args;
27535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27536 if (!SWIG_IsOK(res1)) {
27537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27538 }
27539 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27540 {
27541 PyThreadState* __tstate = wxPyBeginAllowThreads();
27542 result = (PyObject *)(arg1)->GetSelf();
27543 wxPyEndAllowThreads(__tstate);
27544 if (PyErr_Occurred()) SWIG_fail;
27545 }
27546 resultobj = result;
27547 return resultobj;
27548 fail:
27549 return NULL;
27550 }
27551
27552
27553 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27554 PyObject *obj;
27555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27556 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27557 return SWIG_Py_Void();
27558 }
27559
27560 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27561 return SWIG_Python_InitShadowInstance(args);
27562 }
27563
27564 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27565 PyObject *resultobj = 0;
27566 wxWindow *arg1 = (wxWindow *) 0 ;
27567 wxDateTime *arg2 = 0 ;
27568 wxEventType arg3 ;
27569 wxDateEvent *result = 0 ;
27570 void *argp1 = 0 ;
27571 int res1 = 0 ;
27572 void *argp2 = 0 ;
27573 int res2 = 0 ;
27574 int val3 ;
27575 int ecode3 = 0 ;
27576 PyObject * obj0 = 0 ;
27577 PyObject * obj1 = 0 ;
27578 PyObject * obj2 = 0 ;
27579 char * kwnames[] = {
27580 (char *) "win",(char *) "dt",(char *) "type", NULL
27581 };
27582
27583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27585 if (!SWIG_IsOK(res1)) {
27586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27587 }
27588 arg1 = reinterpret_cast< wxWindow * >(argp1);
27589 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27590 if (!SWIG_IsOK(res2)) {
27591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27592 }
27593 if (!argp2) {
27594 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27595 }
27596 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27597 ecode3 = SWIG_AsVal_int(obj2, &val3);
27598 if (!SWIG_IsOK(ecode3)) {
27599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27600 }
27601 arg3 = static_cast< wxEventType >(val3);
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27609 return resultobj;
27610 fail:
27611 return NULL;
27612 }
27613
27614
27615 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27616 PyObject *resultobj = 0;
27617 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27618 wxDateTime *result = 0 ;
27619 void *argp1 = 0 ;
27620 int res1 = 0 ;
27621 PyObject *swig_obj[1] ;
27622
27623 if (!args) SWIG_fail;
27624 swig_obj[0] = args;
27625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27626 if (!SWIG_IsOK(res1)) {
27627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27628 }
27629 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 {
27633 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27634 result = (wxDateTime *) &_result_ref;
27635 }
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27640 return resultobj;
27641 fail:
27642 return NULL;
27643 }
27644
27645
27646 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27647 PyObject *resultobj = 0;
27648 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27649 wxDateTime *arg2 = 0 ;
27650 void *argp1 = 0 ;
27651 int res1 = 0 ;
27652 void *argp2 = 0 ;
27653 int res2 = 0 ;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 char * kwnames[] = {
27657 (char *) "self",(char *) "date", NULL
27658 };
27659
27660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27662 if (!SWIG_IsOK(res1)) {
27663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27664 }
27665 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27666 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27667 if (!SWIG_IsOK(res2)) {
27668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27669 }
27670 if (!argp2) {
27671 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27672 }
27673 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27674 {
27675 PyThreadState* __tstate = wxPyBeginAllowThreads();
27676 (arg1)->SetDate((wxDateTime const &)*arg2);
27677 wxPyEndAllowThreads(__tstate);
27678 if (PyErr_Occurred()) SWIG_fail;
27679 }
27680 resultobj = SWIG_Py_Void();
27681 return resultobj;
27682 fail:
27683 return NULL;
27684 }
27685
27686
27687 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27688 PyObject *obj;
27689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27690 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27691 return SWIG_Py_Void();
27692 }
27693
27694 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27695 return SWIG_Python_InitShadowInstance(args);
27696 }
27697
27698 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27699 PyObject *resultobj = 0;
27700 wxPyApp *result = 0 ;
27701
27702 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 result = (wxPyApp *)new_wxPyApp();
27706 wxPyEndAllowThreads(__tstate);
27707 if (PyErr_Occurred()) SWIG_fail;
27708 }
27709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27710 return resultobj;
27711 fail:
27712 return NULL;
27713 }
27714
27715
27716 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27717 PyObject *resultobj = 0;
27718 wxPyApp *arg1 = (wxPyApp *) 0 ;
27719 void *argp1 = 0 ;
27720 int res1 = 0 ;
27721 PyObject *swig_obj[1] ;
27722
27723 if (!args) SWIG_fail;
27724 swig_obj[0] = args;
27725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27726 if (!SWIG_IsOK(res1)) {
27727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27728 }
27729 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 delete arg1;
27733
27734 wxPyEndAllowThreads(__tstate);
27735 if (PyErr_Occurred()) SWIG_fail;
27736 }
27737 resultobj = SWIG_Py_Void();
27738 return resultobj;
27739 fail:
27740 return NULL;
27741 }
27742
27743
27744 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj = 0;
27746 wxPyApp *arg1 = (wxPyApp *) 0 ;
27747 PyObject *arg2 = (PyObject *) 0 ;
27748 PyObject *arg3 = (PyObject *) 0 ;
27749 bool arg4 ;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 bool val4 ;
27753 int ecode4 = 0 ;
27754 PyObject * obj0 = 0 ;
27755 PyObject * obj1 = 0 ;
27756 PyObject * obj2 = 0 ;
27757 PyObject * obj3 = 0 ;
27758 char * kwnames[] = {
27759 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27760 };
27761
27762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27764 if (!SWIG_IsOK(res1)) {
27765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27766 }
27767 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27768 arg2 = obj1;
27769 arg3 = obj2;
27770 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27771 if (!SWIG_IsOK(ecode4)) {
27772 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27773 }
27774 arg4 = static_cast< bool >(val4);
27775 {
27776 PyThreadState* __tstate = wxPyBeginAllowThreads();
27777 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27778 wxPyEndAllowThreads(__tstate);
27779 if (PyErr_Occurred()) SWIG_fail;
27780 }
27781 resultobj = SWIG_Py_Void();
27782 return resultobj;
27783 fail:
27784 return NULL;
27785 }
27786
27787
27788 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27789 PyObject *resultobj = 0;
27790 wxPyApp *arg1 = (wxPyApp *) 0 ;
27791 wxString result;
27792 void *argp1 = 0 ;
27793 int res1 = 0 ;
27794 PyObject *swig_obj[1] ;
27795
27796 if (!args) SWIG_fail;
27797 swig_obj[0] = args;
27798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27799 if (!SWIG_IsOK(res1)) {
27800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27801 }
27802 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27803 {
27804 PyThreadState* __tstate = wxPyBeginAllowThreads();
27805 result = ((wxPyApp const *)arg1)->GetAppName();
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 {
27810 #if wxUSE_UNICODE
27811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27812 #else
27813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27814 #endif
27815 }
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27823 PyObject *resultobj = 0;
27824 wxPyApp *arg1 = (wxPyApp *) 0 ;
27825 wxString *arg2 = 0 ;
27826 void *argp1 = 0 ;
27827 int res1 = 0 ;
27828 bool temp2 = false ;
27829 PyObject * obj0 = 0 ;
27830 PyObject * obj1 = 0 ;
27831 char * kwnames[] = {
27832 (char *) "self",(char *) "name", NULL
27833 };
27834
27835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27837 if (!SWIG_IsOK(res1)) {
27838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27839 }
27840 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27841 {
27842 arg2 = wxString_in_helper(obj1);
27843 if (arg2 == NULL) SWIG_fail;
27844 temp2 = true;
27845 }
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 (arg1)->SetAppName((wxString const &)*arg2);
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 resultobj = SWIG_Py_Void();
27853 {
27854 if (temp2)
27855 delete arg2;
27856 }
27857 return resultobj;
27858 fail:
27859 {
27860 if (temp2)
27861 delete arg2;
27862 }
27863 return NULL;
27864 }
27865
27866
27867 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27868 PyObject *resultobj = 0;
27869 wxPyApp *arg1 = (wxPyApp *) 0 ;
27870 wxString result;
27871 void *argp1 = 0 ;
27872 int res1 = 0 ;
27873 PyObject *swig_obj[1] ;
27874
27875 if (!args) SWIG_fail;
27876 swig_obj[0] = args;
27877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27880 }
27881 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27882 {
27883 PyThreadState* __tstate = wxPyBeginAllowThreads();
27884 result = ((wxPyApp const *)arg1)->GetClassName();
27885 wxPyEndAllowThreads(__tstate);
27886 if (PyErr_Occurred()) SWIG_fail;
27887 }
27888 {
27889 #if wxUSE_UNICODE
27890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27891 #else
27892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27893 #endif
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27902 PyObject *resultobj = 0;
27903 wxPyApp *arg1 = (wxPyApp *) 0 ;
27904 wxString *arg2 = 0 ;
27905 void *argp1 = 0 ;
27906 int res1 = 0 ;
27907 bool temp2 = false ;
27908 PyObject * obj0 = 0 ;
27909 PyObject * obj1 = 0 ;
27910 char * kwnames[] = {
27911 (char *) "self",(char *) "name", NULL
27912 };
27913
27914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27916 if (!SWIG_IsOK(res1)) {
27917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27918 }
27919 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27920 {
27921 arg2 = wxString_in_helper(obj1);
27922 if (arg2 == NULL) SWIG_fail;
27923 temp2 = true;
27924 }
27925 {
27926 PyThreadState* __tstate = wxPyBeginAllowThreads();
27927 (arg1)->SetClassName((wxString const &)*arg2);
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 resultobj = SWIG_Py_Void();
27932 {
27933 if (temp2)
27934 delete arg2;
27935 }
27936 return resultobj;
27937 fail:
27938 {
27939 if (temp2)
27940 delete arg2;
27941 }
27942 return NULL;
27943 }
27944
27945
27946 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27947 PyObject *resultobj = 0;
27948 wxPyApp *arg1 = (wxPyApp *) 0 ;
27949 wxString *result = 0 ;
27950 void *argp1 = 0 ;
27951 int res1 = 0 ;
27952 PyObject *swig_obj[1] ;
27953
27954 if (!args) SWIG_fail;
27955 swig_obj[0] = args;
27956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27957 if (!SWIG_IsOK(res1)) {
27958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27959 }
27960 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 {
27964 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27965 result = (wxString *) &_result_ref;
27966 }
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 {
27971 #if wxUSE_UNICODE
27972 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27973 #else
27974 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27975 #endif
27976 }
27977 return resultobj;
27978 fail:
27979 return NULL;
27980 }
27981
27982
27983 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27984 PyObject *resultobj = 0;
27985 wxPyApp *arg1 = (wxPyApp *) 0 ;
27986 wxString *arg2 = 0 ;
27987 void *argp1 = 0 ;
27988 int res1 = 0 ;
27989 bool temp2 = false ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "name", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28000 }
28001 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28002 {
28003 arg2 = wxString_in_helper(obj1);
28004 if (arg2 == NULL) SWIG_fail;
28005 temp2 = true;
28006 }
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 (arg1)->SetVendorName((wxString const &)*arg2);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_Py_Void();
28014 {
28015 if (temp2)
28016 delete arg2;
28017 }
28018 return resultobj;
28019 fail:
28020 {
28021 if (temp2)
28022 delete arg2;
28023 }
28024 return NULL;
28025 }
28026
28027
28028 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28029 PyObject *resultobj = 0;
28030 wxPyApp *arg1 = (wxPyApp *) 0 ;
28031 wxAppTraits *result = 0 ;
28032 void *argp1 = 0 ;
28033 int res1 = 0 ;
28034 PyObject *swig_obj[1] ;
28035
28036 if (!args) SWIG_fail;
28037 swig_obj[0] = args;
28038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28039 if (!SWIG_IsOK(res1)) {
28040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28041 }
28042 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28043 {
28044 PyThreadState* __tstate = wxPyBeginAllowThreads();
28045 result = (wxAppTraits *)(arg1)->GetTraits();
28046 wxPyEndAllowThreads(__tstate);
28047 if (PyErr_Occurred()) SWIG_fail;
28048 }
28049 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28050 return resultobj;
28051 fail:
28052 return NULL;
28053 }
28054
28055
28056 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28057 PyObject *resultobj = 0;
28058 wxPyApp *arg1 = (wxPyApp *) 0 ;
28059 void *argp1 = 0 ;
28060 int res1 = 0 ;
28061 PyObject *swig_obj[1] ;
28062
28063 if (!args) SWIG_fail;
28064 swig_obj[0] = args;
28065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28066 if (!SWIG_IsOK(res1)) {
28067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28068 }
28069 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 (arg1)->ProcessPendingEvents();
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 resultobj = SWIG_Py_Void();
28077 return resultobj;
28078 fail:
28079 return NULL;
28080 }
28081
28082
28083 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28084 PyObject *resultobj = 0;
28085 wxPyApp *arg1 = (wxPyApp *) 0 ;
28086 bool arg2 = (bool) false ;
28087 bool result;
28088 void *argp1 = 0 ;
28089 int res1 = 0 ;
28090 bool val2 ;
28091 int ecode2 = 0 ;
28092 PyObject * obj0 = 0 ;
28093 PyObject * obj1 = 0 ;
28094 char * kwnames[] = {
28095 (char *) "self",(char *) "onlyIfNeeded", NULL
28096 };
28097
28098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28100 if (!SWIG_IsOK(res1)) {
28101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28102 }
28103 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28104 if (obj1) {
28105 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28106 if (!SWIG_IsOK(ecode2)) {
28107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28108 }
28109 arg2 = static_cast< bool >(val2);
28110 }
28111 {
28112 PyThreadState* __tstate = wxPyBeginAllowThreads();
28113 result = (bool)(arg1)->Yield(arg2);
28114 wxPyEndAllowThreads(__tstate);
28115 if (PyErr_Occurred()) SWIG_fail;
28116 }
28117 {
28118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28119 }
28120 return resultobj;
28121 fail:
28122 return NULL;
28123 }
28124
28125
28126 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28127 PyObject *resultobj = 0;
28128 wxPyApp *arg1 = (wxPyApp *) 0 ;
28129 void *argp1 = 0 ;
28130 int res1 = 0 ;
28131 PyObject *swig_obj[1] ;
28132
28133 if (!args) SWIG_fail;
28134 swig_obj[0] = args;
28135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28136 if (!SWIG_IsOK(res1)) {
28137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28138 }
28139 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 (arg1)->WakeUpIdle();
28143 wxPyEndAllowThreads(__tstate);
28144 if (PyErr_Occurred()) SWIG_fail;
28145 }
28146 resultobj = SWIG_Py_Void();
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28154 PyObject *resultobj = 0;
28155 bool result;
28156
28157 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (bool)wxPyApp::IsMainLoopRunning();
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 {
28165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28166 }
28167 return resultobj;
28168 fail:
28169 return NULL;
28170 }
28171
28172
28173 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28174 PyObject *resultobj = 0;
28175 wxPyApp *arg1 = (wxPyApp *) 0 ;
28176 int result;
28177 void *argp1 = 0 ;
28178 int res1 = 0 ;
28179 PyObject *swig_obj[1] ;
28180
28181 if (!args) SWIG_fail;
28182 swig_obj[0] = args;
28183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28184 if (!SWIG_IsOK(res1)) {
28185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28186 }
28187 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28188 {
28189 PyThreadState* __tstate = wxPyBeginAllowThreads();
28190 result = (int)(arg1)->MainLoop();
28191 wxPyEndAllowThreads(__tstate);
28192 if (PyErr_Occurred()) SWIG_fail;
28193 }
28194 resultobj = SWIG_From_int(static_cast< int >(result));
28195 return resultobj;
28196 fail:
28197 return NULL;
28198 }
28199
28200
28201 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28202 PyObject *resultobj = 0;
28203 wxPyApp *arg1 = (wxPyApp *) 0 ;
28204 void *argp1 = 0 ;
28205 int res1 = 0 ;
28206 PyObject *swig_obj[1] ;
28207
28208 if (!args) SWIG_fail;
28209 swig_obj[0] = args;
28210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28211 if (!SWIG_IsOK(res1)) {
28212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28213 }
28214 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28215 {
28216 PyThreadState* __tstate = wxPyBeginAllowThreads();
28217 (arg1)->Exit();
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 resultobj = SWIG_Py_Void();
28222 return resultobj;
28223 fail:
28224 return NULL;
28225 }
28226
28227
28228 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28229 PyObject *resultobj = 0;
28230 wxPyApp *arg1 = (wxPyApp *) 0 ;
28231 wxLayoutDirection result;
28232 void *argp1 = 0 ;
28233 int res1 = 0 ;
28234 PyObject *swig_obj[1] ;
28235
28236 if (!args) SWIG_fail;
28237 swig_obj[0] = args;
28238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28239 if (!SWIG_IsOK(res1)) {
28240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28241 }
28242 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28243 {
28244 PyThreadState* __tstate = wxPyBeginAllowThreads();
28245 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 resultobj = SWIG_From_int(static_cast< int >(result));
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(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_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28268 }
28269 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28270 {
28271 PyThreadState* __tstate = wxPyBeginAllowThreads();
28272 (arg1)->ExitMainLoop();
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_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28284 PyObject *resultobj = 0;
28285 wxPyApp *arg1 = (wxPyApp *) 0 ;
28286 bool result;
28287 void *argp1 = 0 ;
28288 int res1 = 0 ;
28289 PyObject *swig_obj[1] ;
28290
28291 if (!args) SWIG_fail;
28292 swig_obj[0] = args;
28293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28294 if (!SWIG_IsOK(res1)) {
28295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28296 }
28297 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28298 {
28299 PyThreadState* __tstate = wxPyBeginAllowThreads();
28300 result = (bool)(arg1)->Pending();
28301 wxPyEndAllowThreads(__tstate);
28302 if (PyErr_Occurred()) SWIG_fail;
28303 }
28304 {
28305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28306 }
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28314 PyObject *resultobj = 0;
28315 wxPyApp *arg1 = (wxPyApp *) 0 ;
28316 bool result;
28317 void *argp1 = 0 ;
28318 int res1 = 0 ;
28319 PyObject *swig_obj[1] ;
28320
28321 if (!args) SWIG_fail;
28322 swig_obj[0] = args;
28323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28324 if (!SWIG_IsOK(res1)) {
28325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28326 }
28327 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (bool)(arg1)->Dispatch();
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 {
28335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28336 }
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 PyObject *resultobj = 0;
28345 wxPyApp *arg1 = (wxPyApp *) 0 ;
28346 bool result;
28347 void *argp1 = 0 ;
28348 int res1 = 0 ;
28349 PyObject *swig_obj[1] ;
28350
28351 if (!args) SWIG_fail;
28352 swig_obj[0] = args;
28353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28354 if (!SWIG_IsOK(res1)) {
28355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28356 }
28357 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (bool)(arg1)->ProcessIdle();
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 {
28365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28366 }
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28374 PyObject *resultobj = 0;
28375 wxPyApp *arg1 = (wxPyApp *) 0 ;
28376 wxWindow *arg2 = (wxWindow *) 0 ;
28377 wxIdleEvent *arg3 = 0 ;
28378 bool result;
28379 void *argp1 = 0 ;
28380 int res1 = 0 ;
28381 void *argp2 = 0 ;
28382 int res2 = 0 ;
28383 void *argp3 = 0 ;
28384 int res3 = 0 ;
28385 PyObject * obj0 = 0 ;
28386 PyObject * obj1 = 0 ;
28387 PyObject * obj2 = 0 ;
28388 char * kwnames[] = {
28389 (char *) "self",(char *) "win",(char *) "event", NULL
28390 };
28391
28392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28394 if (!SWIG_IsOK(res1)) {
28395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28396 }
28397 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28399 if (!SWIG_IsOK(res2)) {
28400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28401 }
28402 arg2 = reinterpret_cast< wxWindow * >(argp2);
28403 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28404 if (!SWIG_IsOK(res3)) {
28405 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28406 }
28407 if (!argp3) {
28408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28409 }
28410 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28411 {
28412 PyThreadState* __tstate = wxPyBeginAllowThreads();
28413 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 {
28418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28419 }
28420 return resultobj;
28421 fail:
28422 return NULL;
28423 }
28424
28425
28426 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28427 PyObject *resultobj = 0;
28428 wxPyApp *arg1 = (wxPyApp *) 0 ;
28429 bool result;
28430 void *argp1 = 0 ;
28431 int res1 = 0 ;
28432 PyObject *swig_obj[1] ;
28433
28434 if (!args) SWIG_fail;
28435 swig_obj[0] = args;
28436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28437 if (!SWIG_IsOK(res1)) {
28438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28439 }
28440 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28441 {
28442 PyThreadState* __tstate = wxPyBeginAllowThreads();
28443 result = (bool)((wxPyApp const *)arg1)->IsActive();
28444 wxPyEndAllowThreads(__tstate);
28445 if (PyErr_Occurred()) SWIG_fail;
28446 }
28447 {
28448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28449 }
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28457 PyObject *resultobj = 0;
28458 wxPyApp *arg1 = (wxPyApp *) 0 ;
28459 wxWindow *arg2 = (wxWindow *) 0 ;
28460 void *argp1 = 0 ;
28461 int res1 = 0 ;
28462 void *argp2 = 0 ;
28463 int res2 = 0 ;
28464 PyObject * obj0 = 0 ;
28465 PyObject * obj1 = 0 ;
28466 char * kwnames[] = {
28467 (char *) "self",(char *) "win", NULL
28468 };
28469
28470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28472 if (!SWIG_IsOK(res1)) {
28473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28474 }
28475 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28477 if (!SWIG_IsOK(res2)) {
28478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28479 }
28480 arg2 = reinterpret_cast< wxWindow * >(argp2);
28481 {
28482 PyThreadState* __tstate = wxPyBeginAllowThreads();
28483 (arg1)->SetTopWindow(arg2);
28484 wxPyEndAllowThreads(__tstate);
28485 if (PyErr_Occurred()) SWIG_fail;
28486 }
28487 resultobj = SWIG_Py_Void();
28488 return resultobj;
28489 fail:
28490 return NULL;
28491 }
28492
28493
28494 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28495 PyObject *resultobj = 0;
28496 wxPyApp *arg1 = (wxPyApp *) 0 ;
28497 wxWindow *result = 0 ;
28498 void *argp1 = 0 ;
28499 int res1 = 0 ;
28500 PyObject *swig_obj[1] ;
28501
28502 if (!args) SWIG_fail;
28503 swig_obj[0] = args;
28504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28505 if (!SWIG_IsOK(res1)) {
28506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28507 }
28508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 {
28516 resultobj = wxPyMake_wxObject(result, (bool)0);
28517 }
28518 return resultobj;
28519 fail:
28520 return NULL;
28521 }
28522
28523
28524 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28525 PyObject *resultobj = 0;
28526 wxPyApp *arg1 = (wxPyApp *) 0 ;
28527 bool arg2 ;
28528 void *argp1 = 0 ;
28529 int res1 = 0 ;
28530 bool val2 ;
28531 int ecode2 = 0 ;
28532 PyObject * obj0 = 0 ;
28533 PyObject * obj1 = 0 ;
28534 char * kwnames[] = {
28535 (char *) "self",(char *) "flag", NULL
28536 };
28537
28538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28540 if (!SWIG_IsOK(res1)) {
28541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28542 }
28543 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28544 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28545 if (!SWIG_IsOK(ecode2)) {
28546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28547 }
28548 arg2 = static_cast< bool >(val2);
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 (arg1)->SetExitOnFrameDelete(arg2);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_Py_Void();
28556 return resultobj;
28557 fail:
28558 return NULL;
28559 }
28560
28561
28562 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28563 PyObject *resultobj = 0;
28564 wxPyApp *arg1 = (wxPyApp *) 0 ;
28565 bool result;
28566 void *argp1 = 0 ;
28567 int res1 = 0 ;
28568 PyObject *swig_obj[1] ;
28569
28570 if (!args) SWIG_fail;
28571 swig_obj[0] = args;
28572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28573 if (!SWIG_IsOK(res1)) {
28574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28575 }
28576 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28580 wxPyEndAllowThreads(__tstate);
28581 if (PyErr_Occurred()) SWIG_fail;
28582 }
28583 {
28584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28585 }
28586 return resultobj;
28587 fail:
28588 return NULL;
28589 }
28590
28591
28592 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28593 PyObject *resultobj = 0;
28594 wxPyApp *arg1 = (wxPyApp *) 0 ;
28595 bool arg2 ;
28596 void *argp1 = 0 ;
28597 int res1 = 0 ;
28598 bool val2 ;
28599 int ecode2 = 0 ;
28600 PyObject * obj0 = 0 ;
28601 PyObject * obj1 = 0 ;
28602 char * kwnames[] = {
28603 (char *) "self",(char *) "flag", NULL
28604 };
28605
28606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28608 if (!SWIG_IsOK(res1)) {
28609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28610 }
28611 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28612 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28613 if (!SWIG_IsOK(ecode2)) {
28614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28615 }
28616 arg2 = static_cast< bool >(val2);
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 (arg1)->SetUseBestVisual(arg2);
28620 wxPyEndAllowThreads(__tstate);
28621 if (PyErr_Occurred()) SWIG_fail;
28622 }
28623 resultobj = SWIG_Py_Void();
28624 return resultobj;
28625 fail:
28626 return NULL;
28627 }
28628
28629
28630 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28631 PyObject *resultobj = 0;
28632 wxPyApp *arg1 = (wxPyApp *) 0 ;
28633 bool result;
28634 void *argp1 = 0 ;
28635 int res1 = 0 ;
28636 PyObject *swig_obj[1] ;
28637
28638 if (!args) SWIG_fail;
28639 swig_obj[0] = args;
28640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28641 if (!SWIG_IsOK(res1)) {
28642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28643 }
28644 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 {
28652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28653 }
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28661 PyObject *resultobj = 0;
28662 wxPyApp *arg1 = (wxPyApp *) 0 ;
28663 int arg2 ;
28664 void *argp1 = 0 ;
28665 int res1 = 0 ;
28666 int val2 ;
28667 int ecode2 = 0 ;
28668 PyObject * obj0 = 0 ;
28669 PyObject * obj1 = 0 ;
28670 char * kwnames[] = {
28671 (char *) "self",(char *) "mode", NULL
28672 };
28673
28674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28676 if (!SWIG_IsOK(res1)) {
28677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28678 }
28679 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28680 ecode2 = SWIG_AsVal_int(obj1, &val2);
28681 if (!SWIG_IsOK(ecode2)) {
28682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28683 }
28684 arg2 = static_cast< int >(val2);
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 (arg1)->SetPrintMode(arg2);
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 resultobj = SWIG_Py_Void();
28692 return resultobj;
28693 fail:
28694 return NULL;
28695 }
28696
28697
28698 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28699 PyObject *resultobj = 0;
28700 wxPyApp *arg1 = (wxPyApp *) 0 ;
28701 int result;
28702 void *argp1 = 0 ;
28703 int res1 = 0 ;
28704 PyObject *swig_obj[1] ;
28705
28706 if (!args) SWIG_fail;
28707 swig_obj[0] = args;
28708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28709 if (!SWIG_IsOK(res1)) {
28710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28711 }
28712 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28716 wxPyEndAllowThreads(__tstate);
28717 if (PyErr_Occurred()) SWIG_fail;
28718 }
28719 resultobj = SWIG_From_int(static_cast< int >(result));
28720 return resultobj;
28721 fail:
28722 return NULL;
28723 }
28724
28725
28726 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28727 PyObject *resultobj = 0;
28728 wxPyApp *arg1 = (wxPyApp *) 0 ;
28729 int arg2 ;
28730 void *argp1 = 0 ;
28731 int res1 = 0 ;
28732 int val2 ;
28733 int ecode2 = 0 ;
28734 PyObject * obj0 = 0 ;
28735 PyObject * obj1 = 0 ;
28736 char * kwnames[] = {
28737 (char *) "self",(char *) "mode", NULL
28738 };
28739
28740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28742 if (!SWIG_IsOK(res1)) {
28743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28744 }
28745 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28746 ecode2 = SWIG_AsVal_int(obj1, &val2);
28747 if (!SWIG_IsOK(ecode2)) {
28748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28749 }
28750 arg2 = static_cast< int >(val2);
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 (arg1)->SetAssertMode(arg2);
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_Py_Void();
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28765 PyObject *resultobj = 0;
28766 wxPyApp *arg1 = (wxPyApp *) 0 ;
28767 int result;
28768 void *argp1 = 0 ;
28769 int res1 = 0 ;
28770 PyObject *swig_obj[1] ;
28771
28772 if (!args) SWIG_fail;
28773 swig_obj[0] = args;
28774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28775 if (!SWIG_IsOK(res1)) {
28776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28777 }
28778 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (int)(arg1)->GetAssertMode();
28782 wxPyEndAllowThreads(__tstate);
28783 if (PyErr_Occurred()) SWIG_fail;
28784 }
28785 resultobj = SWIG_From_int(static_cast< int >(result));
28786 return resultobj;
28787 fail:
28788 return NULL;
28789 }
28790
28791
28792 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28793 PyObject *resultobj = 0;
28794 bool result;
28795
28796 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28797 {
28798 PyThreadState* __tstate = wxPyBeginAllowThreads();
28799 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28800 wxPyEndAllowThreads(__tstate);
28801 if (PyErr_Occurred()) SWIG_fail;
28802 }
28803 {
28804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28805 }
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28813 PyObject *resultobj = 0;
28814 long result;
28815
28816 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28817 {
28818 PyThreadState* __tstate = wxPyBeginAllowThreads();
28819 result = (long)wxPyApp::GetMacAboutMenuItemId();
28820 wxPyEndAllowThreads(__tstate);
28821 if (PyErr_Occurred()) SWIG_fail;
28822 }
28823 resultobj = SWIG_From_long(static_cast< long >(result));
28824 return resultobj;
28825 fail:
28826 return NULL;
28827 }
28828
28829
28830 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28831 PyObject *resultobj = 0;
28832 long result;
28833
28834 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 resultobj = SWIG_From_long(static_cast< long >(result));
28842 return resultobj;
28843 fail:
28844 return NULL;
28845 }
28846
28847
28848 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28849 PyObject *resultobj = 0;
28850 long result;
28851
28852 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 result = (long)wxPyApp::GetMacExitMenuItemId();
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 resultobj = SWIG_From_long(static_cast< long >(result));
28860 return resultobj;
28861 fail:
28862 return NULL;
28863 }
28864
28865
28866 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28867 PyObject *resultobj = 0;
28868 wxString result;
28869
28870 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28871 {
28872 PyThreadState* __tstate = wxPyBeginAllowThreads();
28873 result = wxPyApp::GetMacHelpMenuTitleName();
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 {
28878 #if wxUSE_UNICODE
28879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28880 #else
28881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28882 #endif
28883 }
28884 return resultobj;
28885 fail:
28886 return NULL;
28887 }
28888
28889
28890 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28891 PyObject *resultobj = 0;
28892 bool arg1 ;
28893 bool val1 ;
28894 int ecode1 = 0 ;
28895 PyObject * obj0 = 0 ;
28896 char * kwnames[] = {
28897 (char *) "val", NULL
28898 };
28899
28900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28901 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28902 if (!SWIG_IsOK(ecode1)) {
28903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28904 }
28905 arg1 = static_cast< bool >(val1);
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 resultobj = SWIG_Py_Void();
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28920 PyObject *resultobj = 0;
28921 long arg1 ;
28922 long val1 ;
28923 int ecode1 = 0 ;
28924 PyObject * obj0 = 0 ;
28925 char * kwnames[] = {
28926 (char *) "val", NULL
28927 };
28928
28929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28930 ecode1 = SWIG_AsVal_long(obj0, &val1);
28931 if (!SWIG_IsOK(ecode1)) {
28932 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28933 }
28934 arg1 = static_cast< long >(val1);
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 wxPyApp::SetMacAboutMenuItemId(arg1);
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 resultobj = SWIG_Py_Void();
28942 return resultobj;
28943 fail:
28944 return NULL;
28945 }
28946
28947
28948 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28949 PyObject *resultobj = 0;
28950 long arg1 ;
28951 long val1 ;
28952 int ecode1 = 0 ;
28953 PyObject * obj0 = 0 ;
28954 char * kwnames[] = {
28955 (char *) "val", NULL
28956 };
28957
28958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28959 ecode1 = SWIG_AsVal_long(obj0, &val1);
28960 if (!SWIG_IsOK(ecode1)) {
28961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28962 }
28963 arg1 = static_cast< long >(val1);
28964 {
28965 PyThreadState* __tstate = wxPyBeginAllowThreads();
28966 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 resultobj = SWIG_Py_Void();
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28978 PyObject *resultobj = 0;
28979 long arg1 ;
28980 long val1 ;
28981 int ecode1 = 0 ;
28982 PyObject * obj0 = 0 ;
28983 char * kwnames[] = {
28984 (char *) "val", NULL
28985 };
28986
28987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28988 ecode1 = SWIG_AsVal_long(obj0, &val1);
28989 if (!SWIG_IsOK(ecode1)) {
28990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28991 }
28992 arg1 = static_cast< long >(val1);
28993 {
28994 PyThreadState* __tstate = wxPyBeginAllowThreads();
28995 wxPyApp::SetMacExitMenuItemId(arg1);
28996 wxPyEndAllowThreads(__tstate);
28997 if (PyErr_Occurred()) SWIG_fail;
28998 }
28999 resultobj = SWIG_Py_Void();
29000 return resultobj;
29001 fail:
29002 return NULL;
29003 }
29004
29005
29006 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29007 PyObject *resultobj = 0;
29008 wxString *arg1 = 0 ;
29009 bool temp1 = false ;
29010 PyObject * obj0 = 0 ;
29011 char * kwnames[] = {
29012 (char *) "val", NULL
29013 };
29014
29015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29016 {
29017 arg1 = wxString_in_helper(obj0);
29018 if (arg1 == NULL) SWIG_fail;
29019 temp1 = true;
29020 }
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_Py_Void();
29028 {
29029 if (temp1)
29030 delete arg1;
29031 }
29032 return resultobj;
29033 fail:
29034 {
29035 if (temp1)
29036 delete arg1;
29037 }
29038 return NULL;
29039 }
29040
29041
29042 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29043 PyObject *resultobj = 0;
29044 wxPyApp *arg1 = (wxPyApp *) 0 ;
29045 void *argp1 = 0 ;
29046 int res1 = 0 ;
29047 PyObject *swig_obj[1] ;
29048
29049 if (!args) SWIG_fail;
29050 swig_obj[0] = args;
29051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29052 if (!SWIG_IsOK(res1)) {
29053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29054 }
29055 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29056 {
29057 PyThreadState* __tstate = wxPyBeginAllowThreads();
29058 (arg1)->_BootstrapApp();
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 resultobj = SWIG_Py_Void();
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29070 PyObject *resultobj = 0;
29071 int result;
29072
29073 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29074 {
29075 PyThreadState* __tstate = wxPyBeginAllowThreads();
29076 result = (int)wxPyApp_GetComCtl32Version();
29077 wxPyEndAllowThreads(__tstate);
29078 if (PyErr_Occurred()) SWIG_fail;
29079 }
29080 resultobj = SWIG_From_int(static_cast< int >(result));
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29088 PyObject *resultobj = 0;
29089 bool result;
29090
29091 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29092 {
29093 PyThreadState* __tstate = wxPyBeginAllowThreads();
29094 result = (bool)wxPyApp_IsDisplayAvailable();
29095 wxPyEndAllowThreads(__tstate);
29096 if (PyErr_Occurred()) SWIG_fail;
29097 }
29098 {
29099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29100 }
29101 return resultobj;
29102 fail:
29103 return NULL;
29104 }
29105
29106
29107 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 PyObject *obj;
29109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29110 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29111 return SWIG_Py_Void();
29112 }
29113
29114 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29115 return SWIG_Python_InitShadowInstance(args);
29116 }
29117
29118 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29119 PyObject *resultobj = 0;
29120
29121 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29122 {
29123 PyThreadState* __tstate = wxPyBeginAllowThreads();
29124 wxExit();
29125 wxPyEndAllowThreads(__tstate);
29126 if (PyErr_Occurred()) SWIG_fail;
29127 }
29128 resultobj = SWIG_Py_Void();
29129 return resultobj;
29130 fail:
29131 return NULL;
29132 }
29133
29134
29135 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29136 PyObject *resultobj = 0;
29137 bool result;
29138
29139 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = (bool)wxYield();
29143 wxPyEndAllowThreads(__tstate);
29144 if (PyErr_Occurred()) SWIG_fail;
29145 }
29146 {
29147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29148 }
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29156 PyObject *resultobj = 0;
29157 bool result;
29158
29159 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29160 {
29161 PyThreadState* __tstate = wxPyBeginAllowThreads();
29162 result = (bool)wxYieldIfNeeded();
29163 wxPyEndAllowThreads(__tstate);
29164 if (PyErr_Occurred()) SWIG_fail;
29165 }
29166 {
29167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29168 }
29169 return resultobj;
29170 fail:
29171 return NULL;
29172 }
29173
29174
29175 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29176 PyObject *resultobj = 0;
29177 wxWindow *arg1 = (wxWindow *) NULL ;
29178 bool arg2 = (bool) false ;
29179 bool result;
29180 void *argp1 = 0 ;
29181 int res1 = 0 ;
29182 bool val2 ;
29183 int ecode2 = 0 ;
29184 PyObject * obj0 = 0 ;
29185 PyObject * obj1 = 0 ;
29186 char * kwnames[] = {
29187 (char *) "win",(char *) "onlyIfNeeded", NULL
29188 };
29189
29190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29191 if (obj0) {
29192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29193 if (!SWIG_IsOK(res1)) {
29194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29195 }
29196 arg1 = reinterpret_cast< wxWindow * >(argp1);
29197 }
29198 if (obj1) {
29199 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29200 if (!SWIG_IsOK(ecode2)) {
29201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29202 }
29203 arg2 = static_cast< bool >(val2);
29204 }
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (bool)wxSafeYield(arg1,arg2);
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 {
29212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29213 }
29214 return resultobj;
29215 fail:
29216 return NULL;
29217 }
29218
29219
29220 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29221 PyObject *resultobj = 0;
29222
29223 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29224 {
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 wxWakeUpIdle();
29227 wxPyEndAllowThreads(__tstate);
29228 if (PyErr_Occurred()) SWIG_fail;
29229 }
29230 resultobj = SWIG_Py_Void();
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29238 PyObject *resultobj = 0;
29239 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29240 wxEvent *arg2 = 0 ;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 void *argp2 = 0 ;
29244 int res2 = 0 ;
29245 PyObject * obj0 = 0 ;
29246 PyObject * obj1 = 0 ;
29247 char * kwnames[] = {
29248 (char *) "dest",(char *) "event", NULL
29249 };
29250
29251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29253 if (!SWIG_IsOK(res1)) {
29254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29255 }
29256 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29257 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29258 if (!SWIG_IsOK(res2)) {
29259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29260 }
29261 if (!argp2) {
29262 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29263 }
29264 arg2 = reinterpret_cast< wxEvent * >(argp2);
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 wxPostEvent(arg1,*arg2);
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_Py_Void();
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280
29281 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29282 {
29283 PyThreadState* __tstate = wxPyBeginAllowThreads();
29284 wxApp_CleanUp();
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_Py_Void();
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296 PyObject *resultobj = 0;
29297 wxPyApp *result = 0 ;
29298
29299 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (wxPyApp *)wxPyGetApp();
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 {
29307 resultobj = wxPyMake_wxObject(result, 0);
29308 }
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj = 0;
29317 char *arg1 = (char *) 0 ;
29318 int res1 ;
29319 char *buf1 = 0 ;
29320 int alloc1 = 0 ;
29321 PyObject * obj0 = 0 ;
29322 char * kwnames[] = {
29323 (char *) "encoding", NULL
29324 };
29325
29326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29327 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29328 if (!SWIG_IsOK(res1)) {
29329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29330 }
29331 arg1 = buf1;
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 wxSetDefaultPyEncoding((char const *)arg1);
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 resultobj = SWIG_Py_Void();
29339 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29340 return resultobj;
29341 fail:
29342 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29348 PyObject *resultobj = 0;
29349 char *result = 0 ;
29350
29351 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29352 {
29353 PyThreadState* __tstate = wxPyBeginAllowThreads();
29354 result = (char *)wxGetDefaultPyEncoding();
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 resultobj = SWIG_FromCharPtr(result);
29359 return resultobj;
29360 fail:
29361 return NULL;
29362 }
29363
29364
29365 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29366 PyObject *resultobj = 0;
29367 wxEventLoop *result = 0 ;
29368
29369 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29370 {
29371 PyThreadState* __tstate = wxPyBeginAllowThreads();
29372 result = (wxEventLoop *)new wxEventLoop();
29373 wxPyEndAllowThreads(__tstate);
29374 if (PyErr_Occurred()) SWIG_fail;
29375 }
29376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29377 return resultobj;
29378 fail:
29379 return NULL;
29380 }
29381
29382
29383 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29384 PyObject *resultobj = 0;
29385 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29386 void *argp1 = 0 ;
29387 int res1 = 0 ;
29388 PyObject *swig_obj[1] ;
29389
29390 if (!args) SWIG_fail;
29391 swig_obj[0] = args;
29392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29393 if (!SWIG_IsOK(res1)) {
29394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29395 }
29396 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 delete arg1;
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 resultobj = SWIG_Py_Void();
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29412 PyObject *resultobj = 0;
29413 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29414 int result;
29415 void *argp1 = 0 ;
29416 int res1 = 0 ;
29417 PyObject *swig_obj[1] ;
29418
29419 if (!args) SWIG_fail;
29420 swig_obj[0] = args;
29421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29422 if (!SWIG_IsOK(res1)) {
29423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29424 }
29425 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (int)(arg1)->Run();
29429 wxPyEndAllowThreads(__tstate);
29430 if (PyErr_Occurred()) SWIG_fail;
29431 }
29432 resultobj = SWIG_From_int(static_cast< int >(result));
29433 return resultobj;
29434 fail:
29435 return NULL;
29436 }
29437
29438
29439 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29440 PyObject *resultobj = 0;
29441 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29442 int arg2 = (int) 0 ;
29443 void *argp1 = 0 ;
29444 int res1 = 0 ;
29445 int val2 ;
29446 int ecode2 = 0 ;
29447 PyObject * obj0 = 0 ;
29448 PyObject * obj1 = 0 ;
29449 char * kwnames[] = {
29450 (char *) "self",(char *) "rc", NULL
29451 };
29452
29453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29457 }
29458 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29459 if (obj1) {
29460 ecode2 = SWIG_AsVal_int(obj1, &val2);
29461 if (!SWIG_IsOK(ecode2)) {
29462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29463 }
29464 arg2 = static_cast< int >(val2);
29465 }
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 (arg1)->Exit(arg2);
29469 wxPyEndAllowThreads(__tstate);
29470 if (PyErr_Occurred()) SWIG_fail;
29471 }
29472 resultobj = SWIG_Py_Void();
29473 return resultobj;
29474 fail:
29475 return NULL;
29476 }
29477
29478
29479 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29480 PyObject *resultobj = 0;
29481 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29482 bool result;
29483 void *argp1 = 0 ;
29484 int res1 = 0 ;
29485 PyObject *swig_obj[1] ;
29486
29487 if (!args) SWIG_fail;
29488 swig_obj[0] = args;
29489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29490 if (!SWIG_IsOK(res1)) {
29491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29492 }
29493 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29494 {
29495 PyThreadState* __tstate = wxPyBeginAllowThreads();
29496 result = (bool)((wxEventLoop const *)arg1)->Pending();
29497 wxPyEndAllowThreads(__tstate);
29498 if (PyErr_Occurred()) SWIG_fail;
29499 }
29500 {
29501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29502 }
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29510 PyObject *resultobj = 0;
29511 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29512 bool result;
29513 void *argp1 = 0 ;
29514 int res1 = 0 ;
29515 PyObject *swig_obj[1] ;
29516
29517 if (!args) SWIG_fail;
29518 swig_obj[0] = args;
29519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29520 if (!SWIG_IsOK(res1)) {
29521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29522 }
29523 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 result = (bool)(arg1)->Dispatch();
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 {
29531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29532 }
29533 return resultobj;
29534 fail:
29535 return NULL;
29536 }
29537
29538
29539 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29540 PyObject *resultobj = 0;
29541 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29542 bool result;
29543 void *argp1 = 0 ;
29544 int res1 = 0 ;
29545 PyObject *swig_obj[1] ;
29546
29547 if (!args) SWIG_fail;
29548 swig_obj[0] = args;
29549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29550 if (!SWIG_IsOK(res1)) {
29551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29552 }
29553 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29554 {
29555 PyThreadState* __tstate = wxPyBeginAllowThreads();
29556 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29557 wxPyEndAllowThreads(__tstate);
29558 if (PyErr_Occurred()) SWIG_fail;
29559 }
29560 {
29561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29562 }
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29570 PyObject *resultobj = 0;
29571 wxEventLoop *result = 0 ;
29572
29573 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (wxEventLoop *)wxEventLoop::GetActive();
29577 wxPyEndAllowThreads(__tstate);
29578 if (PyErr_Occurred()) SWIG_fail;
29579 }
29580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29581 return resultobj;
29582 fail:
29583 return NULL;
29584 }
29585
29586
29587 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29588 PyObject *resultobj = 0;
29589 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29590 void *argp1 = 0 ;
29591 int res1 = 0 ;
29592 PyObject * obj0 = 0 ;
29593 char * kwnames[] = {
29594 (char *) "loop", NULL
29595 };
29596
29597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29599 if (!SWIG_IsOK(res1)) {
29600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29601 }
29602 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 wxEventLoop::SetActive(arg1);
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 resultobj = SWIG_Py_Void();
29610 return resultobj;
29611 fail:
29612 return NULL;
29613 }
29614
29615
29616 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29617 PyObject *obj;
29618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29619 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29620 return SWIG_Py_Void();
29621 }
29622
29623 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29624 return SWIG_Python_InitShadowInstance(args);
29625 }
29626
29627 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29628 PyObject *resultobj = 0;
29629 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29630 wxEventLoopActivator *result = 0 ;
29631 void *argp1 = 0 ;
29632 int res1 = 0 ;
29633 PyObject * obj0 = 0 ;
29634 char * kwnames[] = {
29635 (char *) "evtLoop", NULL
29636 };
29637
29638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29640 if (!SWIG_IsOK(res1)) {
29641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29642 }
29643 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29644 {
29645 PyThreadState* __tstate = wxPyBeginAllowThreads();
29646 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29647 wxPyEndAllowThreads(__tstate);
29648 if (PyErr_Occurred()) SWIG_fail;
29649 }
29650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29651 return resultobj;
29652 fail:
29653 return NULL;
29654 }
29655
29656
29657 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29658 PyObject *resultobj = 0;
29659 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29660 void *argp1 = 0 ;
29661 int res1 = 0 ;
29662 PyObject *swig_obj[1] ;
29663
29664 if (!args) SWIG_fail;
29665 swig_obj[0] = args;
29666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29669 }
29670 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29671 {
29672 PyThreadState* __tstate = wxPyBeginAllowThreads();
29673 delete arg1;
29674
29675 wxPyEndAllowThreads(__tstate);
29676 if (PyErr_Occurred()) SWIG_fail;
29677 }
29678 resultobj = SWIG_Py_Void();
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29686 PyObject *obj;
29687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29688 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29689 return SWIG_Py_Void();
29690 }
29691
29692 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29693 return SWIG_Python_InitShadowInstance(args);
29694 }
29695
29696 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29697 PyObject *resultobj = 0;
29698 int arg1 = (int) 0 ;
29699 int arg2 = (int) 0 ;
29700 int arg3 = (int) 0 ;
29701 wxAcceleratorEntry *result = 0 ;
29702 int val1 ;
29703 int ecode1 = 0 ;
29704 int val2 ;
29705 int ecode2 = 0 ;
29706 int val3 ;
29707 int ecode3 = 0 ;
29708 PyObject * obj0 = 0 ;
29709 PyObject * obj1 = 0 ;
29710 PyObject * obj2 = 0 ;
29711 char * kwnames[] = {
29712 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29713 };
29714
29715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29716 if (obj0) {
29717 ecode1 = SWIG_AsVal_int(obj0, &val1);
29718 if (!SWIG_IsOK(ecode1)) {
29719 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29720 }
29721 arg1 = static_cast< int >(val1);
29722 }
29723 if (obj1) {
29724 ecode2 = SWIG_AsVal_int(obj1, &val2);
29725 if (!SWIG_IsOK(ecode2)) {
29726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29727 }
29728 arg2 = static_cast< int >(val2);
29729 }
29730 if (obj2) {
29731 ecode3 = SWIG_AsVal_int(obj2, &val3);
29732 if (!SWIG_IsOK(ecode3)) {
29733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29734 }
29735 arg3 = static_cast< int >(val3);
29736 }
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29751 PyObject *resultobj = 0;
29752 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29753 void *argp1 = 0 ;
29754 int res1 = 0 ;
29755 PyObject *swig_obj[1] ;
29756
29757 if (!args) SWIG_fail;
29758 swig_obj[0] = args;
29759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29760 if (!SWIG_IsOK(res1)) {
29761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29762 }
29763 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29764 {
29765 PyThreadState* __tstate = wxPyBeginAllowThreads();
29766 delete arg1;
29767
29768 wxPyEndAllowThreads(__tstate);
29769 if (PyErr_Occurred()) SWIG_fail;
29770 }
29771 resultobj = SWIG_Py_Void();
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29779 PyObject *resultobj = 0;
29780 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29781 int arg2 ;
29782 int arg3 ;
29783 int arg4 ;
29784 void *argp1 = 0 ;
29785 int res1 = 0 ;
29786 int val2 ;
29787 int ecode2 = 0 ;
29788 int val3 ;
29789 int ecode3 = 0 ;
29790 int val4 ;
29791 int ecode4 = 0 ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 PyObject * obj2 = 0 ;
29795 PyObject * obj3 = 0 ;
29796 char * kwnames[] = {
29797 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29798 };
29799
29800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29802 if (!SWIG_IsOK(res1)) {
29803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29804 }
29805 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29806 ecode2 = SWIG_AsVal_int(obj1, &val2);
29807 if (!SWIG_IsOK(ecode2)) {
29808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29809 }
29810 arg2 = static_cast< int >(val2);
29811 ecode3 = SWIG_AsVal_int(obj2, &val3);
29812 if (!SWIG_IsOK(ecode3)) {
29813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29814 }
29815 arg3 = static_cast< int >(val3);
29816 ecode4 = SWIG_AsVal_int(obj3, &val4);
29817 if (!SWIG_IsOK(ecode4)) {
29818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29819 }
29820 arg4 = static_cast< int >(val4);
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 (arg1)->Set(arg2,arg3,arg4);
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 resultobj = SWIG_Py_Void();
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29835 PyObject *resultobj = 0;
29836 wxString *arg1 = 0 ;
29837 wxAcceleratorEntry *result = 0 ;
29838 bool temp1 = false ;
29839 PyObject * obj0 = 0 ;
29840 char * kwnames[] = {
29841 (char *) "str", NULL
29842 };
29843
29844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29845 {
29846 arg1 = wxString_in_helper(obj0);
29847 if (arg1 == NULL) SWIG_fail;
29848 temp1 = true;
29849 }
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29857 {
29858 if (temp1)
29859 delete arg1;
29860 }
29861 return resultobj;
29862 fail:
29863 {
29864 if (temp1)
29865 delete arg1;
29866 }
29867 return NULL;
29868 }
29869
29870
29871 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29872 PyObject *resultobj = 0;
29873 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29874 int result;
29875 void *argp1 = 0 ;
29876 int res1 = 0 ;
29877 PyObject *swig_obj[1] ;
29878
29879 if (!args) SWIG_fail;
29880 swig_obj[0] = args;
29881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29882 if (!SWIG_IsOK(res1)) {
29883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29884 }
29885 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29886 {
29887 PyThreadState* __tstate = wxPyBeginAllowThreads();
29888 result = (int)(arg1)->GetFlags();
29889 wxPyEndAllowThreads(__tstate);
29890 if (PyErr_Occurred()) SWIG_fail;
29891 }
29892 resultobj = SWIG_From_int(static_cast< int >(result));
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29900 PyObject *resultobj = 0;
29901 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29902 int result;
29903 void *argp1 = 0 ;
29904 int res1 = 0 ;
29905 PyObject *swig_obj[1] ;
29906
29907 if (!args) SWIG_fail;
29908 swig_obj[0] = args;
29909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29910 if (!SWIG_IsOK(res1)) {
29911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29912 }
29913 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (int)(arg1)->GetKeyCode();
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 resultobj = SWIG_From_int(static_cast< int >(result));
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29928 PyObject *resultobj = 0;
29929 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29930 int result;
29931 void *argp1 = 0 ;
29932 int res1 = 0 ;
29933 PyObject *swig_obj[1] ;
29934
29935 if (!args) SWIG_fail;
29936 swig_obj[0] = args;
29937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29938 if (!SWIG_IsOK(res1)) {
29939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29940 }
29941 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29942 {
29943 PyThreadState* __tstate = wxPyBeginAllowThreads();
29944 result = (int)(arg1)->GetCommand();
29945 wxPyEndAllowThreads(__tstate);
29946 if (PyErr_Occurred()) SWIG_fail;
29947 }
29948 resultobj = SWIG_From_int(static_cast< int >(result));
29949 return resultobj;
29950 fail:
29951 return NULL;
29952 }
29953
29954
29955 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29956 PyObject *resultobj = 0;
29957 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29958 bool result;
29959 void *argp1 = 0 ;
29960 int res1 = 0 ;
29961 PyObject *swig_obj[1] ;
29962
29963 if (!args) SWIG_fail;
29964 swig_obj[0] = args;
29965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29966 if (!SWIG_IsOK(res1)) {
29967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29968 }
29969 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29970 {
29971 PyThreadState* __tstate = wxPyBeginAllowThreads();
29972 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29973 wxPyEndAllowThreads(__tstate);
29974 if (PyErr_Occurred()) SWIG_fail;
29975 }
29976 {
29977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29978 }
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29986 PyObject *resultobj = 0;
29987 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29988 wxString result;
29989 void *argp1 = 0 ;
29990 int res1 = 0 ;
29991 PyObject *swig_obj[1] ;
29992
29993 if (!args) SWIG_fail;
29994 swig_obj[0] = args;
29995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29996 if (!SWIG_IsOK(res1)) {
29997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29998 }
29999 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30000 {
30001 PyThreadState* __tstate = wxPyBeginAllowThreads();
30002 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 #if wxUSE_UNICODE
30008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30009 #else
30010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30011 #endif
30012 }
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = 0;
30021 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30022 wxString *arg2 = 0 ;
30023 bool result;
30024 void *argp1 = 0 ;
30025 int res1 = 0 ;
30026 bool temp2 = false ;
30027 PyObject * obj0 = 0 ;
30028 PyObject * obj1 = 0 ;
30029 char * kwnames[] = {
30030 (char *) "self",(char *) "str", NULL
30031 };
30032
30033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30035 if (!SWIG_IsOK(res1)) {
30036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30037 }
30038 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30039 {
30040 arg2 = wxString_in_helper(obj1);
30041 if (arg2 == NULL) SWIG_fail;
30042 temp2 = true;
30043 }
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 {
30051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30052 }
30053 {
30054 if (temp2)
30055 delete arg2;
30056 }
30057 return resultobj;
30058 fail:
30059 {
30060 if (temp2)
30061 delete arg2;
30062 }
30063 return NULL;
30064 }
30065
30066
30067 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30068 PyObject *obj;
30069 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30070 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30071 return SWIG_Py_Void();
30072 }
30073
30074 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30075 return SWIG_Python_InitShadowInstance(args);
30076 }
30077
30078 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30079 PyObject *resultobj = 0;
30080 int arg1 ;
30081 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30082 wxAcceleratorTable *result = 0 ;
30083 PyObject * obj0 = 0 ;
30084 char * kwnames[] = {
30085 (char *) "n", NULL
30086 };
30087
30088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30089 {
30090 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30091 if (arg2) arg1 = PyList_Size(obj0);
30092 else arg1 = 0;
30093 }
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30101 return resultobj;
30102 fail:
30103 return NULL;
30104 }
30105
30106
30107 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30108 PyObject *resultobj = 0;
30109 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30110 void *argp1 = 0 ;
30111 int res1 = 0 ;
30112 PyObject *swig_obj[1] ;
30113
30114 if (!args) SWIG_fail;
30115 swig_obj[0] = args;
30116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30117 if (!SWIG_IsOK(res1)) {
30118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30119 }
30120 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 delete arg1;
30124
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_Py_Void();
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30136 PyObject *resultobj = 0;
30137 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30138 bool result;
30139 void *argp1 = 0 ;
30140 int res1 = 0 ;
30141 PyObject *swig_obj[1] ;
30142
30143 if (!args) SWIG_fail;
30144 swig_obj[0] = args;
30145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30146 if (!SWIG_IsOK(res1)) {
30147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30148 }
30149 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30150 {
30151 PyThreadState* __tstate = wxPyBeginAllowThreads();
30152 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
30153 wxPyEndAllowThreads(__tstate);
30154 if (PyErr_Occurred()) SWIG_fail;
30155 }
30156 {
30157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30158 }
30159 return resultobj;
30160 fail:
30161 return NULL;
30162 }
30163
30164
30165 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30166 PyObject *obj;
30167 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30168 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30169 return SWIG_Py_Void();
30170 }
30171
30172 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30173 return SWIG_Python_InitShadowInstance(args);
30174 }
30175
30176 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30177 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30178 return 1;
30179 }
30180
30181
30182 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30183 PyObject *pyobj = 0;
30184
30185 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30186 return pyobj;
30187 }
30188
30189
30190 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30191 PyObject *resultobj = 0;
30192 wxString *arg1 = 0 ;
30193 wxAcceleratorEntry *result = 0 ;
30194 bool temp1 = false ;
30195 PyObject * obj0 = 0 ;
30196 char * kwnames[] = {
30197 (char *) "label", NULL
30198 };
30199
30200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30201 {
30202 arg1 = wxString_in_helper(obj0);
30203 if (arg1 == NULL) SWIG_fail;
30204 temp1 = true;
30205 }
30206 {
30207 PyThreadState* __tstate = wxPyBeginAllowThreads();
30208 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30209 wxPyEndAllowThreads(__tstate);
30210 if (PyErr_Occurred()) SWIG_fail;
30211 }
30212 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30213 {
30214 if (temp1)
30215 delete arg1;
30216 }
30217 return resultobj;
30218 fail:
30219 {
30220 if (temp1)
30221 delete arg1;
30222 }
30223 return NULL;
30224 }
30225
30226
30227 SWIGINTERN int PanelNameStr_set(PyObject *) {
30228 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30229 return 1;
30230 }
30231
30232
30233 SWIGINTERN PyObject *PanelNameStr_get(void) {
30234 PyObject *pyobj = 0;
30235
30236 {
30237 #if wxUSE_UNICODE
30238 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30239 #else
30240 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30241 #endif
30242 }
30243 return pyobj;
30244 }
30245
30246
30247 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30248 PyObject *resultobj = 0;
30249 wxVisualAttributes *result = 0 ;
30250
30251 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 result = (wxVisualAttributes *)new_wxVisualAttributes();
30255 wxPyEndAllowThreads(__tstate);
30256 if (PyErr_Occurred()) SWIG_fail;
30257 }
30258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30259 return resultobj;
30260 fail:
30261 return NULL;
30262 }
30263
30264
30265 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30266 PyObject *resultobj = 0;
30267 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30268 void *argp1 = 0 ;
30269 int res1 = 0 ;
30270 PyObject *swig_obj[1] ;
30271
30272 if (!args) SWIG_fail;
30273 swig_obj[0] = args;
30274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30275 if (!SWIG_IsOK(res1)) {
30276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30277 }
30278 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 delete_wxVisualAttributes(arg1);
30282
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 resultobj = SWIG_Py_Void();
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30294 PyObject *resultobj = 0;
30295 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30296 wxFont *arg2 = (wxFont *) 0 ;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 void *argp2 = 0 ;
30300 int res2 = 0 ;
30301 PyObject *swig_obj[2] ;
30302
30303 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30305 if (!SWIG_IsOK(res1)) {
30306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30307 }
30308 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30309 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30310 if (!SWIG_IsOK(res2)) {
30311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30312 }
30313 arg2 = reinterpret_cast< wxFont * >(argp2);
30314 if (arg1) (arg1)->font = *arg2;
30315
30316 resultobj = SWIG_Py_Void();
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30324 PyObject *resultobj = 0;
30325 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30326 wxFont *result = 0 ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 PyObject *swig_obj[1] ;
30330
30331 if (!args) SWIG_fail;
30332 swig_obj[0] = args;
30333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30334 if (!SWIG_IsOK(res1)) {
30335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30336 }
30337 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30338 result = (wxFont *)& ((arg1)->font);
30339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30347 PyObject *resultobj = 0;
30348 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30349 wxColour *arg2 = (wxColour *) 0 ;
30350 void *argp1 = 0 ;
30351 int res1 = 0 ;
30352 void *argp2 = 0 ;
30353 int res2 = 0 ;
30354 PyObject *swig_obj[2] ;
30355
30356 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30358 if (!SWIG_IsOK(res1)) {
30359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30360 }
30361 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30362 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30363 if (!SWIG_IsOK(res2)) {
30364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30365 }
30366 arg2 = reinterpret_cast< wxColour * >(argp2);
30367 if (arg1) (arg1)->colFg = *arg2;
30368
30369 resultobj = SWIG_Py_Void();
30370 return resultobj;
30371 fail:
30372 return NULL;
30373 }
30374
30375
30376 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30377 PyObject *resultobj = 0;
30378 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30379 wxColour *result = 0 ;
30380 void *argp1 = 0 ;
30381 int res1 = 0 ;
30382 PyObject *swig_obj[1] ;
30383
30384 if (!args) SWIG_fail;
30385 swig_obj[0] = args;
30386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30387 if (!SWIG_IsOK(res1)) {
30388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30389 }
30390 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30391 result = (wxColour *)& ((arg1)->colFg);
30392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30393 return resultobj;
30394 fail:
30395 return NULL;
30396 }
30397
30398
30399 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30400 PyObject *resultobj = 0;
30401 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30402 wxColour *arg2 = (wxColour *) 0 ;
30403 void *argp1 = 0 ;
30404 int res1 = 0 ;
30405 void *argp2 = 0 ;
30406 int res2 = 0 ;
30407 PyObject *swig_obj[2] ;
30408
30409 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30411 if (!SWIG_IsOK(res1)) {
30412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30413 }
30414 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30415 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30416 if (!SWIG_IsOK(res2)) {
30417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30418 }
30419 arg2 = reinterpret_cast< wxColour * >(argp2);
30420 if (arg1) (arg1)->colBg = *arg2;
30421
30422 resultobj = SWIG_Py_Void();
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30430 PyObject *resultobj = 0;
30431 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30432 wxColour *result = 0 ;
30433 void *argp1 = 0 ;
30434 int res1 = 0 ;
30435 PyObject *swig_obj[1] ;
30436
30437 if (!args) SWIG_fail;
30438 swig_obj[0] = args;
30439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30440 if (!SWIG_IsOK(res1)) {
30441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30442 }
30443 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30444 result = (wxColour *)& ((arg1)->colBg);
30445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30446 return resultobj;
30447 fail:
30448 return NULL;
30449 }
30450
30451
30452 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30453 PyObject *obj;
30454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30455 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30456 return SWIG_Py_Void();
30457 }
30458
30459 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30460 return SWIG_Python_InitShadowInstance(args);
30461 }
30462
30463 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30464 PyObject *resultobj = 0;
30465 wxWindow *arg1 = (wxWindow *) 0 ;
30466 int arg2 = (int) (int)-1 ;
30467 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30468 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30469 wxSize const &arg4_defvalue = wxDefaultSize ;
30470 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30471 long arg5 = (long) 0 ;
30472 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30473 wxString *arg6 = (wxString *) &arg6_defvalue ;
30474 wxWindow *result = 0 ;
30475 void *argp1 = 0 ;
30476 int res1 = 0 ;
30477 int val2 ;
30478 int ecode2 = 0 ;
30479 wxPoint temp3 ;
30480 wxSize temp4 ;
30481 long val5 ;
30482 int ecode5 = 0 ;
30483 bool temp6 = false ;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 PyObject * obj2 = 0 ;
30487 PyObject * obj3 = 0 ;
30488 PyObject * obj4 = 0 ;
30489 PyObject * obj5 = 0 ;
30490 char * kwnames[] = {
30491 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30492 };
30493
30494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30496 if (!SWIG_IsOK(res1)) {
30497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30498 }
30499 arg1 = reinterpret_cast< wxWindow * >(argp1);
30500 if (obj1) {
30501 ecode2 = SWIG_AsVal_int(obj1, &val2);
30502 if (!SWIG_IsOK(ecode2)) {
30503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30504 }
30505 arg2 = static_cast< int >(val2);
30506 }
30507 if (obj2) {
30508 {
30509 arg3 = &temp3;
30510 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30511 }
30512 }
30513 if (obj3) {
30514 {
30515 arg4 = &temp4;
30516 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30517 }
30518 }
30519 if (obj4) {
30520 ecode5 = SWIG_AsVal_long(obj4, &val5);
30521 if (!SWIG_IsOK(ecode5)) {
30522 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30523 }
30524 arg5 = static_cast< long >(val5);
30525 }
30526 if (obj5) {
30527 {
30528 arg6 = wxString_in_helper(obj5);
30529 if (arg6 == NULL) SWIG_fail;
30530 temp6 = true;
30531 }
30532 }
30533 {
30534 if (!wxPyCheckForApp()) SWIG_fail;
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30541 {
30542 if (temp6)
30543 delete arg6;
30544 }
30545 return resultobj;
30546 fail:
30547 {
30548 if (temp6)
30549 delete arg6;
30550 }
30551 return NULL;
30552 }
30553
30554
30555 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30556 PyObject *resultobj = 0;
30557 wxWindow *result = 0 ;
30558
30559 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30560 {
30561 if (!wxPyCheckForApp()) SWIG_fail;
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (wxWindow *)new wxWindow();
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj = 0;
30576 wxWindow *arg1 = (wxWindow *) 0 ;
30577 wxWindow *arg2 = (wxWindow *) 0 ;
30578 int arg3 = (int) (int)-1 ;
30579 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30580 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30581 wxSize const &arg5_defvalue = wxDefaultSize ;
30582 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30583 long arg6 = (long) 0 ;
30584 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30585 wxString *arg7 = (wxString *) &arg7_defvalue ;
30586 bool result;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 void *argp2 = 0 ;
30590 int res2 = 0 ;
30591 int val3 ;
30592 int ecode3 = 0 ;
30593 wxPoint temp4 ;
30594 wxSize temp5 ;
30595 long val6 ;
30596 int ecode6 = 0 ;
30597 bool temp7 = false ;
30598 PyObject * obj0 = 0 ;
30599 PyObject * obj1 = 0 ;
30600 PyObject * obj2 = 0 ;
30601 PyObject * obj3 = 0 ;
30602 PyObject * obj4 = 0 ;
30603 PyObject * obj5 = 0 ;
30604 PyObject * obj6 = 0 ;
30605 char * kwnames[] = {
30606 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30607 };
30608
30609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30616 if (!SWIG_IsOK(res2)) {
30617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30618 }
30619 arg2 = reinterpret_cast< wxWindow * >(argp2);
30620 if (obj2) {
30621 ecode3 = SWIG_AsVal_int(obj2, &val3);
30622 if (!SWIG_IsOK(ecode3)) {
30623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30624 }
30625 arg3 = static_cast< int >(val3);
30626 }
30627 if (obj3) {
30628 {
30629 arg4 = &temp4;
30630 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30631 }
30632 }
30633 if (obj4) {
30634 {
30635 arg5 = &temp5;
30636 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30637 }
30638 }
30639 if (obj5) {
30640 ecode6 = SWIG_AsVal_long(obj5, &val6);
30641 if (!SWIG_IsOK(ecode6)) {
30642 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30643 }
30644 arg6 = static_cast< long >(val6);
30645 }
30646 if (obj6) {
30647 {
30648 arg7 = wxString_in_helper(obj6);
30649 if (arg7 == NULL) SWIG_fail;
30650 temp7 = true;
30651 }
30652 }
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 {
30660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30661 }
30662 {
30663 if (temp7)
30664 delete arg7;
30665 }
30666 return resultobj;
30667 fail:
30668 {
30669 if (temp7)
30670 delete arg7;
30671 }
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30677 PyObject *resultobj = 0;
30678 wxWindow *arg1 = (wxWindow *) 0 ;
30679 bool arg2 = (bool) false ;
30680 bool result;
30681 void *argp1 = 0 ;
30682 int res1 = 0 ;
30683 bool val2 ;
30684 int ecode2 = 0 ;
30685 PyObject * obj0 = 0 ;
30686 PyObject * obj1 = 0 ;
30687 char * kwnames[] = {
30688 (char *) "self",(char *) "force", NULL
30689 };
30690
30691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30693 if (!SWIG_IsOK(res1)) {
30694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30695 }
30696 arg1 = reinterpret_cast< wxWindow * >(argp1);
30697 if (obj1) {
30698 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30699 if (!SWIG_IsOK(ecode2)) {
30700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30701 }
30702 arg2 = static_cast< bool >(val2);
30703 }
30704 {
30705 PyThreadState* __tstate = wxPyBeginAllowThreads();
30706 result = (bool)(arg1)->Close(arg2);
30707 wxPyEndAllowThreads(__tstate);
30708 if (PyErr_Occurred()) SWIG_fail;
30709 }
30710 {
30711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30720 PyObject *resultobj = 0;
30721 wxWindow *arg1 = (wxWindow *) 0 ;
30722 bool result;
30723 void *argp1 = 0 ;
30724 int res1 = 0 ;
30725 PyObject *swig_obj[1] ;
30726
30727 if (!args) SWIG_fail;
30728 swig_obj[0] = args;
30729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30730 if (!SWIG_IsOK(res1)) {
30731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30732 }
30733 arg1 = reinterpret_cast< wxWindow * >(argp1);
30734 {
30735 PyThreadState* __tstate = wxPyBeginAllowThreads();
30736 result = (bool)(arg1)->Destroy();
30737 wxPyEndAllowThreads(__tstate);
30738 if (PyErr_Occurred()) SWIG_fail;
30739 }
30740 {
30741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30742 }
30743 return resultobj;
30744 fail:
30745 return NULL;
30746 }
30747
30748
30749 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30750 PyObject *resultobj = 0;
30751 wxWindow *arg1 = (wxWindow *) 0 ;
30752 bool result;
30753 void *argp1 = 0 ;
30754 int res1 = 0 ;
30755 PyObject *swig_obj[1] ;
30756
30757 if (!args) SWIG_fail;
30758 swig_obj[0] = args;
30759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30760 if (!SWIG_IsOK(res1)) {
30761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30762 }
30763 arg1 = reinterpret_cast< wxWindow * >(argp1);
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = (bool)(arg1)->DestroyChildren();
30767 wxPyEndAllowThreads(__tstate);
30768 if (PyErr_Occurred()) SWIG_fail;
30769 }
30770 {
30771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30772 }
30773 return resultobj;
30774 fail:
30775 return NULL;
30776 }
30777
30778
30779 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30780 PyObject *resultobj = 0;
30781 wxWindow *arg1 = (wxWindow *) 0 ;
30782 bool result;
30783 void *argp1 = 0 ;
30784 int res1 = 0 ;
30785 PyObject *swig_obj[1] ;
30786
30787 if (!args) SWIG_fail;
30788 swig_obj[0] = args;
30789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30790 if (!SWIG_IsOK(res1)) {
30791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30792 }
30793 arg1 = reinterpret_cast< wxWindow * >(argp1);
30794 {
30795 PyThreadState* __tstate = wxPyBeginAllowThreads();
30796 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30797 wxPyEndAllowThreads(__tstate);
30798 if (PyErr_Occurred()) SWIG_fail;
30799 }
30800 {
30801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30802 }
30803 return resultobj;
30804 fail:
30805 return NULL;
30806 }
30807
30808
30809 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30810 PyObject *resultobj = 0;
30811 wxWindow *arg1 = (wxWindow *) 0 ;
30812 wxString *arg2 = 0 ;
30813 void *argp1 = 0 ;
30814 int res1 = 0 ;
30815 bool temp2 = false ;
30816 PyObject * obj0 = 0 ;
30817 PyObject * obj1 = 0 ;
30818 char * kwnames[] = {
30819 (char *) "self",(char *) "label", NULL
30820 };
30821
30822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30826 }
30827 arg1 = reinterpret_cast< wxWindow * >(argp1);
30828 {
30829 arg2 = wxString_in_helper(obj1);
30830 if (arg2 == NULL) SWIG_fail;
30831 temp2 = true;
30832 }
30833 {
30834 PyThreadState* __tstate = wxPyBeginAllowThreads();
30835 (arg1)->SetLabel((wxString const &)*arg2);
30836 wxPyEndAllowThreads(__tstate);
30837 if (PyErr_Occurred()) SWIG_fail;
30838 }
30839 resultobj = SWIG_Py_Void();
30840 {
30841 if (temp2)
30842 delete arg2;
30843 }
30844 return resultobj;
30845 fail:
30846 {
30847 if (temp2)
30848 delete arg2;
30849 }
30850 return NULL;
30851 }
30852
30853
30854 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30855 PyObject *resultobj = 0;
30856 wxWindow *arg1 = (wxWindow *) 0 ;
30857 wxString result;
30858 void *argp1 = 0 ;
30859 int res1 = 0 ;
30860 PyObject *swig_obj[1] ;
30861
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxWindow * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 result = ((wxWindow const *)arg1)->GetLabel();
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 {
30876 #if wxUSE_UNICODE
30877 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30878 #else
30879 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30880 #endif
30881 }
30882 return resultobj;
30883 fail:
30884 return NULL;
30885 }
30886
30887
30888 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30889 PyObject *resultobj = 0;
30890 wxWindow *arg1 = (wxWindow *) 0 ;
30891 wxString *arg2 = 0 ;
30892 void *argp1 = 0 ;
30893 int res1 = 0 ;
30894 bool temp2 = false ;
30895 PyObject * obj0 = 0 ;
30896 PyObject * obj1 = 0 ;
30897 char * kwnames[] = {
30898 (char *) "self",(char *) "name", NULL
30899 };
30900
30901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30903 if (!SWIG_IsOK(res1)) {
30904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30905 }
30906 arg1 = reinterpret_cast< wxWindow * >(argp1);
30907 {
30908 arg2 = wxString_in_helper(obj1);
30909 if (arg2 == NULL) SWIG_fail;
30910 temp2 = true;
30911 }
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 (arg1)->SetName((wxString const &)*arg2);
30915 wxPyEndAllowThreads(__tstate);
30916 if (PyErr_Occurred()) SWIG_fail;
30917 }
30918 resultobj = SWIG_Py_Void();
30919 {
30920 if (temp2)
30921 delete arg2;
30922 }
30923 return resultobj;
30924 fail:
30925 {
30926 if (temp2)
30927 delete arg2;
30928 }
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30934 PyObject *resultobj = 0;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 wxString result;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 PyObject *swig_obj[1] ;
30940
30941 if (!args) SWIG_fail;
30942 swig_obj[0] = args;
30943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30944 if (!SWIG_IsOK(res1)) {
30945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30946 }
30947 arg1 = reinterpret_cast< wxWindow * >(argp1);
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 result = ((wxWindow const *)arg1)->GetName();
30951 wxPyEndAllowThreads(__tstate);
30952 if (PyErr_Occurred()) SWIG_fail;
30953 }
30954 {
30955 #if wxUSE_UNICODE
30956 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30957 #else
30958 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30959 #endif
30960 }
30961 return resultobj;
30962 fail:
30963 return NULL;
30964 }
30965
30966
30967 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30968 PyObject *resultobj = 0;
30969 wxWindow *arg1 = (wxWindow *) 0 ;
30970 wxWindowVariant arg2 ;
30971 void *argp1 = 0 ;
30972 int res1 = 0 ;
30973 int val2 ;
30974 int ecode2 = 0 ;
30975 PyObject * obj0 = 0 ;
30976 PyObject * obj1 = 0 ;
30977 char * kwnames[] = {
30978 (char *) "self",(char *) "variant", NULL
30979 };
30980
30981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30983 if (!SWIG_IsOK(res1)) {
30984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30985 }
30986 arg1 = reinterpret_cast< wxWindow * >(argp1);
30987 ecode2 = SWIG_AsVal_int(obj1, &val2);
30988 if (!SWIG_IsOK(ecode2)) {
30989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30990 }
30991 arg2 = static_cast< wxWindowVariant >(val2);
30992 {
30993 PyThreadState* __tstate = wxPyBeginAllowThreads();
30994 (arg1)->SetWindowVariant(arg2);
30995 wxPyEndAllowThreads(__tstate);
30996 if (PyErr_Occurred()) SWIG_fail;
30997 }
30998 resultobj = SWIG_Py_Void();
30999 return resultobj;
31000 fail:
31001 return NULL;
31002 }
31003
31004
31005 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31006 PyObject *resultobj = 0;
31007 wxWindow *arg1 = (wxWindow *) 0 ;
31008 wxWindowVariant result;
31009 void *argp1 = 0 ;
31010 int res1 = 0 ;
31011 PyObject *swig_obj[1] ;
31012
31013 if (!args) SWIG_fail;
31014 swig_obj[0] = args;
31015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31018 }
31019 arg1 = reinterpret_cast< wxWindow * >(argp1);
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 resultobj = SWIG_From_int(static_cast< int >(result));
31027 return resultobj;
31028 fail:
31029 return NULL;
31030 }
31031
31032
31033 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31034 PyObject *resultobj = 0;
31035 wxWindow *arg1 = (wxWindow *) 0 ;
31036 int arg2 ;
31037 void *argp1 = 0 ;
31038 int res1 = 0 ;
31039 int val2 ;
31040 int ecode2 = 0 ;
31041 PyObject * obj0 = 0 ;
31042 PyObject * obj1 = 0 ;
31043 char * kwnames[] = {
31044 (char *) "self",(char *) "winid", NULL
31045 };
31046
31047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31049 if (!SWIG_IsOK(res1)) {
31050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31051 }
31052 arg1 = reinterpret_cast< wxWindow * >(argp1);
31053 ecode2 = SWIG_AsVal_int(obj1, &val2);
31054 if (!SWIG_IsOK(ecode2)) {
31055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31056 }
31057 arg2 = static_cast< int >(val2);
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 (arg1)->SetId(arg2);
31061 wxPyEndAllowThreads(__tstate);
31062 if (PyErr_Occurred()) SWIG_fail;
31063 }
31064 resultobj = SWIG_Py_Void();
31065 return resultobj;
31066 fail:
31067 return NULL;
31068 }
31069
31070
31071 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31072 PyObject *resultobj = 0;
31073 wxWindow *arg1 = (wxWindow *) 0 ;
31074 int result;
31075 void *argp1 = 0 ;
31076 int res1 = 0 ;
31077 PyObject *swig_obj[1] ;
31078
31079 if (!args) SWIG_fail;
31080 swig_obj[0] = args;
31081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31084 }
31085 arg1 = reinterpret_cast< wxWindow * >(argp1);
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 result = (int)((wxWindow const *)arg1)->GetId();
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_From_int(static_cast< int >(result));
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31100 PyObject *resultobj = 0;
31101 int result;
31102
31103 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31104 {
31105 PyThreadState* __tstate = wxPyBeginAllowThreads();
31106 result = (int)wxWindow::NewControlId();
31107 wxPyEndAllowThreads(__tstate);
31108 if (PyErr_Occurred()) SWIG_fail;
31109 }
31110 resultobj = SWIG_From_int(static_cast< int >(result));
31111 return resultobj;
31112 fail:
31113 return NULL;
31114 }
31115
31116
31117 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31118 PyObject *resultobj = 0;
31119 int arg1 ;
31120 int result;
31121 int val1 ;
31122 int ecode1 = 0 ;
31123 PyObject * obj0 = 0 ;
31124 char * kwnames[] = {
31125 (char *) "winid", NULL
31126 };
31127
31128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31129 ecode1 = SWIG_AsVal_int(obj0, &val1);
31130 if (!SWIG_IsOK(ecode1)) {
31131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31132 }
31133 arg1 = static_cast< int >(val1);
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 result = (int)wxWindow::NextControlId(arg1);
31137 wxPyEndAllowThreads(__tstate);
31138 if (PyErr_Occurred()) SWIG_fail;
31139 }
31140 resultobj = SWIG_From_int(static_cast< int >(result));
31141 return resultobj;
31142 fail:
31143 return NULL;
31144 }
31145
31146
31147 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31148 PyObject *resultobj = 0;
31149 int arg1 ;
31150 int result;
31151 int val1 ;
31152 int ecode1 = 0 ;
31153 PyObject * obj0 = 0 ;
31154 char * kwnames[] = {
31155 (char *) "winid", NULL
31156 };
31157
31158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31159 ecode1 = SWIG_AsVal_int(obj0, &val1);
31160 if (!SWIG_IsOK(ecode1)) {
31161 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31162 }
31163 arg1 = static_cast< int >(val1);
31164 {
31165 PyThreadState* __tstate = wxPyBeginAllowThreads();
31166 result = (int)wxWindow::PrevControlId(arg1);
31167 wxPyEndAllowThreads(__tstate);
31168 if (PyErr_Occurred()) SWIG_fail;
31169 }
31170 resultobj = SWIG_From_int(static_cast< int >(result));
31171 return resultobj;
31172 fail:
31173 return NULL;
31174 }
31175
31176
31177 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31178 PyObject *resultobj = 0;
31179 wxWindow *arg1 = (wxWindow *) 0 ;
31180 wxLayoutDirection result;
31181 void *argp1 = 0 ;
31182 int res1 = 0 ;
31183 PyObject *swig_obj[1] ;
31184
31185 if (!args) SWIG_fail;
31186 swig_obj[0] = args;
31187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31188 if (!SWIG_IsOK(res1)) {
31189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31190 }
31191 arg1 = reinterpret_cast< wxWindow * >(argp1);
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 resultobj = SWIG_From_int(static_cast< int >(result));
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31206 PyObject *resultobj = 0;
31207 wxWindow *arg1 = (wxWindow *) 0 ;
31208 wxLayoutDirection arg2 ;
31209 void *argp1 = 0 ;
31210 int res1 = 0 ;
31211 int val2 ;
31212 int ecode2 = 0 ;
31213 PyObject * obj0 = 0 ;
31214 PyObject * obj1 = 0 ;
31215 char * kwnames[] = {
31216 (char *) "self",(char *) "dir", NULL
31217 };
31218
31219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31221 if (!SWIG_IsOK(res1)) {
31222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31223 }
31224 arg1 = reinterpret_cast< wxWindow * >(argp1);
31225 ecode2 = SWIG_AsVal_int(obj1, &val2);
31226 if (!SWIG_IsOK(ecode2)) {
31227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31228 }
31229 arg2 = static_cast< wxLayoutDirection >(val2);
31230 {
31231 PyThreadState* __tstate = wxPyBeginAllowThreads();
31232 (arg1)->SetLayoutDirection(arg2);
31233 wxPyEndAllowThreads(__tstate);
31234 if (PyErr_Occurred()) SWIG_fail;
31235 }
31236 resultobj = SWIG_Py_Void();
31237 return resultobj;
31238 fail:
31239 return NULL;
31240 }
31241
31242
31243 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31244 PyObject *resultobj = 0;
31245 wxWindow *arg1 = (wxWindow *) 0 ;
31246 int arg2 ;
31247 int arg3 ;
31248 int arg4 ;
31249 int result;
31250 void *argp1 = 0 ;
31251 int res1 = 0 ;
31252 int val2 ;
31253 int ecode2 = 0 ;
31254 int val3 ;
31255 int ecode3 = 0 ;
31256 int val4 ;
31257 int ecode4 = 0 ;
31258 PyObject * obj0 = 0 ;
31259 PyObject * obj1 = 0 ;
31260 PyObject * obj2 = 0 ;
31261 PyObject * obj3 = 0 ;
31262 char * kwnames[] = {
31263 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31264 };
31265
31266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31268 if (!SWIG_IsOK(res1)) {
31269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31270 }
31271 arg1 = reinterpret_cast< wxWindow * >(argp1);
31272 ecode2 = SWIG_AsVal_int(obj1, &val2);
31273 if (!SWIG_IsOK(ecode2)) {
31274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31275 }
31276 arg2 = static_cast< int >(val2);
31277 ecode3 = SWIG_AsVal_int(obj2, &val3);
31278 if (!SWIG_IsOK(ecode3)) {
31279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31280 }
31281 arg3 = static_cast< int >(val3);
31282 ecode4 = SWIG_AsVal_int(obj3, &val4);
31283 if (!SWIG_IsOK(ecode4)) {
31284 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31285 }
31286 arg4 = static_cast< int >(val4);
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31290 wxPyEndAllowThreads(__tstate);
31291 if (PyErr_Occurred()) SWIG_fail;
31292 }
31293 resultobj = SWIG_From_int(static_cast< int >(result));
31294 return resultobj;
31295 fail:
31296 return NULL;
31297 }
31298
31299
31300 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31301 PyObject *resultobj = 0;
31302 wxWindow *arg1 = (wxWindow *) 0 ;
31303 wxSize *arg2 = 0 ;
31304 void *argp1 = 0 ;
31305 int res1 = 0 ;
31306 wxSize temp2 ;
31307 PyObject * obj0 = 0 ;
31308 PyObject * obj1 = 0 ;
31309 char * kwnames[] = {
31310 (char *) "self",(char *) "size", NULL
31311 };
31312
31313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31315 if (!SWIG_IsOK(res1)) {
31316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31317 }
31318 arg1 = reinterpret_cast< wxWindow * >(argp1);
31319 {
31320 arg2 = &temp2;
31321 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31322 }
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 (arg1)->SetSize((wxSize const &)*arg2);
31326 wxPyEndAllowThreads(__tstate);
31327 if (PyErr_Occurred()) SWIG_fail;
31328 }
31329 resultobj = SWIG_Py_Void();
31330 return resultobj;
31331 fail:
31332 return NULL;
31333 }
31334
31335
31336 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31337 PyObject *resultobj = 0;
31338 wxWindow *arg1 = (wxWindow *) 0 ;
31339 int arg2 ;
31340 int arg3 ;
31341 int arg4 ;
31342 int arg5 ;
31343 int arg6 = (int) wxSIZE_AUTO ;
31344 void *argp1 = 0 ;
31345 int res1 = 0 ;
31346 int val2 ;
31347 int ecode2 = 0 ;
31348 int val3 ;
31349 int ecode3 = 0 ;
31350 int val4 ;
31351 int ecode4 = 0 ;
31352 int val5 ;
31353 int ecode5 = 0 ;
31354 int val6 ;
31355 int ecode6 = 0 ;
31356 PyObject * obj0 = 0 ;
31357 PyObject * obj1 = 0 ;
31358 PyObject * obj2 = 0 ;
31359 PyObject * obj3 = 0 ;
31360 PyObject * obj4 = 0 ;
31361 PyObject * obj5 = 0 ;
31362 char * kwnames[] = {
31363 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31364 };
31365
31366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31368 if (!SWIG_IsOK(res1)) {
31369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31370 }
31371 arg1 = reinterpret_cast< wxWindow * >(argp1);
31372 ecode2 = SWIG_AsVal_int(obj1, &val2);
31373 if (!SWIG_IsOK(ecode2)) {
31374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31375 }
31376 arg2 = static_cast< int >(val2);
31377 ecode3 = SWIG_AsVal_int(obj2, &val3);
31378 if (!SWIG_IsOK(ecode3)) {
31379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31380 }
31381 arg3 = static_cast< int >(val3);
31382 ecode4 = SWIG_AsVal_int(obj3, &val4);
31383 if (!SWIG_IsOK(ecode4)) {
31384 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31385 }
31386 arg4 = static_cast< int >(val4);
31387 ecode5 = SWIG_AsVal_int(obj4, &val5);
31388 if (!SWIG_IsOK(ecode5)) {
31389 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31390 }
31391 arg5 = static_cast< int >(val5);
31392 if (obj5) {
31393 ecode6 = SWIG_AsVal_int(obj5, &val6);
31394 if (!SWIG_IsOK(ecode6)) {
31395 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31396 }
31397 arg6 = static_cast< int >(val6);
31398 }
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 resultobj = SWIG_Py_Void();
31406 return resultobj;
31407 fail:
31408 return NULL;
31409 }
31410
31411
31412 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31413 PyObject *resultobj = 0;
31414 wxWindow *arg1 = (wxWindow *) 0 ;
31415 wxRect *arg2 = 0 ;
31416 int arg3 = (int) wxSIZE_AUTO ;
31417 void *argp1 = 0 ;
31418 int res1 = 0 ;
31419 wxRect temp2 ;
31420 int val3 ;
31421 int ecode3 = 0 ;
31422 PyObject * obj0 = 0 ;
31423 PyObject * obj1 = 0 ;
31424 PyObject * obj2 = 0 ;
31425 char * kwnames[] = {
31426 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31427 };
31428
31429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31431 if (!SWIG_IsOK(res1)) {
31432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31433 }
31434 arg1 = reinterpret_cast< wxWindow * >(argp1);
31435 {
31436 arg2 = &temp2;
31437 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31438 }
31439 if (obj2) {
31440 ecode3 = SWIG_AsVal_int(obj2, &val3);
31441 if (!SWIG_IsOK(ecode3)) {
31442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31443 }
31444 arg3 = static_cast< int >(val3);
31445 }
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 resultobj = SWIG_Py_Void();
31453 return resultobj;
31454 fail:
31455 return NULL;
31456 }
31457
31458
31459 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31460 PyObject *resultobj = 0;
31461 wxWindow *arg1 = (wxWindow *) 0 ;
31462 int arg2 ;
31463 int arg3 ;
31464 void *argp1 = 0 ;
31465 int res1 = 0 ;
31466 int val2 ;
31467 int ecode2 = 0 ;
31468 int val3 ;
31469 int ecode3 = 0 ;
31470 PyObject * obj0 = 0 ;
31471 PyObject * obj1 = 0 ;
31472 PyObject * obj2 = 0 ;
31473 char * kwnames[] = {
31474 (char *) "self",(char *) "width",(char *) "height", NULL
31475 };
31476
31477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31479 if (!SWIG_IsOK(res1)) {
31480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31481 }
31482 arg1 = reinterpret_cast< wxWindow * >(argp1);
31483 ecode2 = SWIG_AsVal_int(obj1, &val2);
31484 if (!SWIG_IsOK(ecode2)) {
31485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31486 }
31487 arg2 = static_cast< int >(val2);
31488 ecode3 = SWIG_AsVal_int(obj2, &val3);
31489 if (!SWIG_IsOK(ecode3)) {
31490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31491 }
31492 arg3 = static_cast< int >(val3);
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 (arg1)->SetSize(arg2,arg3);
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 resultobj = SWIG_Py_Void();
31500 return resultobj;
31501 fail:
31502 return NULL;
31503 }
31504
31505
31506 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31507 PyObject *resultobj = 0;
31508 wxWindow *arg1 = (wxWindow *) 0 ;
31509 wxPoint *arg2 = 0 ;
31510 int arg3 = (int) wxSIZE_USE_EXISTING ;
31511 void *argp1 = 0 ;
31512 int res1 = 0 ;
31513 wxPoint temp2 ;
31514 int val3 ;
31515 int ecode3 = 0 ;
31516 PyObject * obj0 = 0 ;
31517 PyObject * obj1 = 0 ;
31518 PyObject * obj2 = 0 ;
31519 char * kwnames[] = {
31520 (char *) "self",(char *) "pt",(char *) "flags", NULL
31521 };
31522
31523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31525 if (!SWIG_IsOK(res1)) {
31526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31527 }
31528 arg1 = reinterpret_cast< wxWindow * >(argp1);
31529 {
31530 arg2 = &temp2;
31531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31532 }
31533 if (obj2) {
31534 ecode3 = SWIG_AsVal_int(obj2, &val3);
31535 if (!SWIG_IsOK(ecode3)) {
31536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31537 }
31538 arg3 = static_cast< int >(val3);
31539 }
31540 {
31541 PyThreadState* __tstate = wxPyBeginAllowThreads();
31542 (arg1)->Move((wxPoint const &)*arg2,arg3);
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 resultobj = SWIG_Py_Void();
31547 return resultobj;
31548 fail:
31549 return NULL;
31550 }
31551
31552
31553 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31554 PyObject *resultobj = 0;
31555 wxWindow *arg1 = (wxWindow *) 0 ;
31556 int arg2 ;
31557 int arg3 ;
31558 int arg4 = (int) wxSIZE_USE_EXISTING ;
31559 void *argp1 = 0 ;
31560 int res1 = 0 ;
31561 int val2 ;
31562 int ecode2 = 0 ;
31563 int val3 ;
31564 int ecode3 = 0 ;
31565 int val4 ;
31566 int ecode4 = 0 ;
31567 PyObject * obj0 = 0 ;
31568 PyObject * obj1 = 0 ;
31569 PyObject * obj2 = 0 ;
31570 PyObject * obj3 = 0 ;
31571 char * kwnames[] = {
31572 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31573 };
31574
31575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31577 if (!SWIG_IsOK(res1)) {
31578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31579 }
31580 arg1 = reinterpret_cast< wxWindow * >(argp1);
31581 ecode2 = SWIG_AsVal_int(obj1, &val2);
31582 if (!SWIG_IsOK(ecode2)) {
31583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31584 }
31585 arg2 = static_cast< int >(val2);
31586 ecode3 = SWIG_AsVal_int(obj2, &val3);
31587 if (!SWIG_IsOK(ecode3)) {
31588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31589 }
31590 arg3 = static_cast< int >(val3);
31591 if (obj3) {
31592 ecode4 = SWIG_AsVal_int(obj3, &val4);
31593 if (!SWIG_IsOK(ecode4)) {
31594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31595 }
31596 arg4 = static_cast< int >(val4);
31597 }
31598 {
31599 PyThreadState* __tstate = wxPyBeginAllowThreads();
31600 (arg1)->Move(arg2,arg3,arg4);
31601 wxPyEndAllowThreads(__tstate);
31602 if (PyErr_Occurred()) SWIG_fail;
31603 }
31604 resultobj = SWIG_Py_Void();
31605 return resultobj;
31606 fail:
31607 return NULL;
31608 }
31609
31610
31611 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31612 PyObject *resultobj = 0;
31613 wxWindow *arg1 = (wxWindow *) 0 ;
31614 wxSize const &arg2_defvalue = wxDefaultSize ;
31615 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31616 void *argp1 = 0 ;
31617 int res1 = 0 ;
31618 wxSize temp2 ;
31619 PyObject * obj0 = 0 ;
31620 PyObject * obj1 = 0 ;
31621 char * kwnames[] = {
31622 (char *) "self",(char *) "size", NULL
31623 };
31624
31625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31627 if (!SWIG_IsOK(res1)) {
31628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31629 }
31630 arg1 = reinterpret_cast< wxWindow * >(argp1);
31631 if (obj1) {
31632 {
31633 arg2 = &temp2;
31634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31635 }
31636 }
31637 {
31638 PyThreadState* __tstate = wxPyBeginAllowThreads();
31639 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31640 wxPyEndAllowThreads(__tstate);
31641 if (PyErr_Occurred()) SWIG_fail;
31642 }
31643 resultobj = SWIG_Py_Void();
31644 return resultobj;
31645 fail:
31646 return NULL;
31647 }
31648
31649
31650 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31651 PyObject *resultobj = 0;
31652 wxWindow *arg1 = (wxWindow *) 0 ;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 PyObject *swig_obj[1] ;
31656
31657 if (!args) SWIG_fail;
31658 swig_obj[0] = args;
31659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31660 if (!SWIG_IsOK(res1)) {
31661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31662 }
31663 arg1 = reinterpret_cast< wxWindow * >(argp1);
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 (arg1)->Raise();
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_Py_Void();
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31678 PyObject *resultobj = 0;
31679 wxWindow *arg1 = (wxWindow *) 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 PyObject *swig_obj[1] ;
31683
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31689 }
31690 arg1 = reinterpret_cast< wxWindow * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 (arg1)->Lower();
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 resultobj = SWIG_Py_Void();
31698 return resultobj;
31699 fail:
31700 return NULL;
31701 }
31702
31703
31704 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31705 PyObject *resultobj = 0;
31706 wxWindow *arg1 = (wxWindow *) 0 ;
31707 wxSize *arg2 = 0 ;
31708 void *argp1 = 0 ;
31709 int res1 = 0 ;
31710 wxSize temp2 ;
31711 PyObject * obj0 = 0 ;
31712 PyObject * obj1 = 0 ;
31713 char * kwnames[] = {
31714 (char *) "self",(char *) "size", NULL
31715 };
31716
31717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31721 }
31722 arg1 = reinterpret_cast< wxWindow * >(argp1);
31723 {
31724 arg2 = &temp2;
31725 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31726 }
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 (arg1)->SetClientSize((wxSize const &)*arg2);
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 resultobj = SWIG_Py_Void();
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj = 0;
31742 wxWindow *arg1 = (wxWindow *) 0 ;
31743 int arg2 ;
31744 int arg3 ;
31745 void *argp1 = 0 ;
31746 int res1 = 0 ;
31747 int val2 ;
31748 int ecode2 = 0 ;
31749 int val3 ;
31750 int ecode3 = 0 ;
31751 PyObject * obj0 = 0 ;
31752 PyObject * obj1 = 0 ;
31753 PyObject * obj2 = 0 ;
31754 char * kwnames[] = {
31755 (char *) "self",(char *) "width",(char *) "height", NULL
31756 };
31757
31758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31760 if (!SWIG_IsOK(res1)) {
31761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31762 }
31763 arg1 = reinterpret_cast< wxWindow * >(argp1);
31764 ecode2 = SWIG_AsVal_int(obj1, &val2);
31765 if (!SWIG_IsOK(ecode2)) {
31766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31767 }
31768 arg2 = static_cast< int >(val2);
31769 ecode3 = SWIG_AsVal_int(obj2, &val3);
31770 if (!SWIG_IsOK(ecode3)) {
31771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31772 }
31773 arg3 = static_cast< int >(val3);
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 (arg1)->SetClientSize(arg2,arg3);
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_Py_Void();
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31788 PyObject *resultobj = 0;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 wxRect *arg2 = 0 ;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 wxRect temp2 ;
31794 PyObject * obj0 = 0 ;
31795 PyObject * obj1 = 0 ;
31796 char * kwnames[] = {
31797 (char *) "self",(char *) "rect", NULL
31798 };
31799
31800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31802 if (!SWIG_IsOK(res1)) {
31803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31804 }
31805 arg1 = reinterpret_cast< wxWindow * >(argp1);
31806 {
31807 arg2 = &temp2;
31808 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31809 }
31810 {
31811 PyThreadState* __tstate = wxPyBeginAllowThreads();
31812 (arg1)->SetClientSize((wxRect const &)*arg2);
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 resultobj = SWIG_Py_Void();
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31824 PyObject *resultobj = 0;
31825 wxWindow *arg1 = (wxWindow *) 0 ;
31826 wxPoint result;
31827 void *argp1 = 0 ;
31828 int res1 = 0 ;
31829 PyObject *swig_obj[1] ;
31830
31831 if (!args) SWIG_fail;
31832 swig_obj[0] = args;
31833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31836 }
31837 arg1 = reinterpret_cast< wxWindow * >(argp1);
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 result = ((wxWindow const *)arg1)->GetPosition();
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *resultobj = 0;
31853 wxWindow *arg1 = (wxWindow *) 0 ;
31854 int *arg2 = (int *) 0 ;
31855 int *arg3 = (int *) 0 ;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 int temp2 ;
31859 int res2 = SWIG_TMPOBJ ;
31860 int temp3 ;
31861 int res3 = SWIG_TMPOBJ ;
31862 PyObject *swig_obj[1] ;
31863
31864 arg2 = &temp2;
31865 arg3 = &temp3;
31866 if (!args) SWIG_fail;
31867 swig_obj[0] = args;
31868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31869 if (!SWIG_IsOK(res1)) {
31870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31871 }
31872 arg1 = reinterpret_cast< wxWindow * >(argp1);
31873 {
31874 PyThreadState* __tstate = wxPyBeginAllowThreads();
31875 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31876 wxPyEndAllowThreads(__tstate);
31877 if (PyErr_Occurred()) SWIG_fail;
31878 }
31879 resultobj = SWIG_Py_Void();
31880 if (SWIG_IsTmpObj(res2)) {
31881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31882 } else {
31883 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31885 }
31886 if (SWIG_IsTmpObj(res3)) {
31887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31888 } else {
31889 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31891 }
31892 return resultobj;
31893 fail:
31894 return NULL;
31895 }
31896
31897
31898 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31899 PyObject *resultobj = 0;
31900 wxWindow *arg1 = (wxWindow *) 0 ;
31901 wxPoint result;
31902 void *argp1 = 0 ;
31903 int res1 = 0 ;
31904 PyObject *swig_obj[1] ;
31905
31906 if (!args) SWIG_fail;
31907 swig_obj[0] = args;
31908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31911 }
31912 arg1 = reinterpret_cast< wxWindow * >(argp1);
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 result = ((wxWindow const *)arg1)->GetScreenPosition();
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31927 PyObject *resultobj = 0;
31928 wxWindow *arg1 = (wxWindow *) 0 ;
31929 int *arg2 = (int *) 0 ;
31930 int *arg3 = (int *) 0 ;
31931 void *argp1 = 0 ;
31932 int res1 = 0 ;
31933 int temp2 ;
31934 int res2 = SWIG_TMPOBJ ;
31935 int temp3 ;
31936 int res3 = SWIG_TMPOBJ ;
31937 PyObject *swig_obj[1] ;
31938
31939 arg2 = &temp2;
31940 arg3 = &temp3;
31941 if (!args) SWIG_fail;
31942 swig_obj[0] = args;
31943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31944 if (!SWIG_IsOK(res1)) {
31945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31946 }
31947 arg1 = reinterpret_cast< wxWindow * >(argp1);
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31951 wxPyEndAllowThreads(__tstate);
31952 if (PyErr_Occurred()) SWIG_fail;
31953 }
31954 resultobj = SWIG_Py_Void();
31955 if (SWIG_IsTmpObj(res2)) {
31956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31957 } else {
31958 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31959 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31960 }
31961 if (SWIG_IsTmpObj(res3)) {
31962 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31963 } else {
31964 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31965 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31966 }
31967 return resultobj;
31968 fail:
31969 return NULL;
31970 }
31971
31972
31973 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31974 PyObject *resultobj = 0;
31975 wxWindow *arg1 = (wxWindow *) 0 ;
31976 wxRect result;
31977 void *argp1 = 0 ;
31978 int res1 = 0 ;
31979 PyObject *swig_obj[1] ;
31980
31981 if (!args) SWIG_fail;
31982 swig_obj[0] = args;
31983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31984 if (!SWIG_IsOK(res1)) {
31985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 {
31989 PyThreadState* __tstate = wxPyBeginAllowThreads();
31990 result = ((wxWindow const *)arg1)->GetScreenRect();
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31995 return resultobj;
31996 fail:
31997 return NULL;
31998 }
31999
32000
32001 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32002 PyObject *resultobj = 0;
32003 wxWindow *arg1 = (wxWindow *) 0 ;
32004 wxSize result;
32005 void *argp1 = 0 ;
32006 int res1 = 0 ;
32007 PyObject *swig_obj[1] ;
32008
32009 if (!args) SWIG_fail;
32010 swig_obj[0] = args;
32011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32012 if (!SWIG_IsOK(res1)) {
32013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32014 }
32015 arg1 = reinterpret_cast< wxWindow * >(argp1);
32016 {
32017 PyThreadState* __tstate = wxPyBeginAllowThreads();
32018 result = ((wxWindow const *)arg1)->GetSize();
32019 wxPyEndAllowThreads(__tstate);
32020 if (PyErr_Occurred()) SWIG_fail;
32021 }
32022 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32030 PyObject *resultobj = 0;
32031 wxWindow *arg1 = (wxWindow *) 0 ;
32032 int *arg2 = (int *) 0 ;
32033 int *arg3 = (int *) 0 ;
32034 void *argp1 = 0 ;
32035 int res1 = 0 ;
32036 int temp2 ;
32037 int res2 = SWIG_TMPOBJ ;
32038 int temp3 ;
32039 int res3 = SWIG_TMPOBJ ;
32040 PyObject *swig_obj[1] ;
32041
32042 arg2 = &temp2;
32043 arg3 = &temp3;
32044 if (!args) SWIG_fail;
32045 swig_obj[0] = args;
32046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32049 }
32050 arg1 = reinterpret_cast< wxWindow * >(argp1);
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_Py_Void();
32058 if (SWIG_IsTmpObj(res2)) {
32059 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32060 } else {
32061 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32062 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32063 }
32064 if (SWIG_IsTmpObj(res3)) {
32065 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32066 } else {
32067 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32068 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32069 }
32070 return resultobj;
32071 fail:
32072 return NULL;
32073 }
32074
32075
32076 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32077 PyObject *resultobj = 0;
32078 wxWindow *arg1 = (wxWindow *) 0 ;
32079 wxRect result;
32080 void *argp1 = 0 ;
32081 int res1 = 0 ;
32082 PyObject *swig_obj[1] ;
32083
32084 if (!args) SWIG_fail;
32085 swig_obj[0] = args;
32086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32087 if (!SWIG_IsOK(res1)) {
32088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32089 }
32090 arg1 = reinterpret_cast< wxWindow * >(argp1);
32091 {
32092 PyThreadState* __tstate = wxPyBeginAllowThreads();
32093 result = ((wxWindow const *)arg1)->GetRect();
32094 wxPyEndAllowThreads(__tstate);
32095 if (PyErr_Occurred()) SWIG_fail;
32096 }
32097 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32098 return resultobj;
32099 fail:
32100 return NULL;
32101 }
32102
32103
32104 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32105 PyObject *resultobj = 0;
32106 wxWindow *arg1 = (wxWindow *) 0 ;
32107 wxSize result;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 PyObject *swig_obj[1] ;
32111
32112 if (!args) SWIG_fail;
32113 swig_obj[0] = args;
32114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32117 }
32118 arg1 = reinterpret_cast< wxWindow * >(argp1);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 result = ((wxWindow const *)arg1)->GetClientSize();
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 wxWindow *arg1 = (wxWindow *) 0 ;
32135 int *arg2 = (int *) 0 ;
32136 int *arg3 = (int *) 0 ;
32137 void *argp1 = 0 ;
32138 int res1 = 0 ;
32139 int temp2 ;
32140 int res2 = SWIG_TMPOBJ ;
32141 int temp3 ;
32142 int res3 = SWIG_TMPOBJ ;
32143 PyObject *swig_obj[1] ;
32144
32145 arg2 = &temp2;
32146 arg3 = &temp3;
32147 if (!args) SWIG_fail;
32148 swig_obj[0] = args;
32149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32150 if (!SWIG_IsOK(res1)) {
32151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32152 }
32153 arg1 = reinterpret_cast< wxWindow * >(argp1);
32154 {
32155 PyThreadState* __tstate = wxPyBeginAllowThreads();
32156 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 resultobj = SWIG_Py_Void();
32161 if (SWIG_IsTmpObj(res2)) {
32162 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32163 } else {
32164 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32165 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32166 }
32167 if (SWIG_IsTmpObj(res3)) {
32168 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32169 } else {
32170 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32171 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32172 }
32173 return resultobj;
32174 fail:
32175 return NULL;
32176 }
32177
32178
32179 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32180 PyObject *resultobj = 0;
32181 wxWindow *arg1 = (wxWindow *) 0 ;
32182 wxPoint result;
32183 void *argp1 = 0 ;
32184 int res1 = 0 ;
32185 PyObject *swig_obj[1] ;
32186
32187 if (!args) SWIG_fail;
32188 swig_obj[0] = args;
32189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32190 if (!SWIG_IsOK(res1)) {
32191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32192 }
32193 arg1 = reinterpret_cast< wxWindow * >(argp1);
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32197 wxPyEndAllowThreads(__tstate);
32198 if (PyErr_Occurred()) SWIG_fail;
32199 }
32200 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 wxRect result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = ((wxWindow const *)arg1)->GetClientRect();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 wxSize result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 PyObject *swig_obj[1] ;
32242
32243 if (!args) SWIG_fail;
32244 swig_obj[0] = args;
32245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32246 if (!SWIG_IsOK(res1)) {
32247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32248 }
32249 arg1 = reinterpret_cast< wxWindow * >(argp1);
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = ((wxWindow const *)arg1)->GetBestSize();
32253 wxPyEndAllowThreads(__tstate);
32254 if (PyErr_Occurred()) SWIG_fail;
32255 }
32256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32264 PyObject *resultobj = 0;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 int *arg2 = (int *) 0 ;
32267 int *arg3 = (int *) 0 ;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 int temp2 ;
32271 int res2 = SWIG_TMPOBJ ;
32272 int temp3 ;
32273 int res3 = SWIG_TMPOBJ ;
32274 PyObject *swig_obj[1] ;
32275
32276 arg2 = &temp2;
32277 arg3 = &temp3;
32278 if (!args) SWIG_fail;
32279 swig_obj[0] = args;
32280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32281 if (!SWIG_IsOK(res1)) {
32282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32283 }
32284 arg1 = reinterpret_cast< wxWindow * >(argp1);
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 resultobj = SWIG_Py_Void();
32292 if (SWIG_IsTmpObj(res2)) {
32293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32294 } else {
32295 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32297 }
32298 if (SWIG_IsTmpObj(res3)) {
32299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32300 } else {
32301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32303 }
32304 return resultobj;
32305 fail:
32306 return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32311 PyObject *resultobj = 0;
32312 wxWindow *arg1 = (wxWindow *) 0 ;
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_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32322 }
32323 arg1 = reinterpret_cast< wxWindow * >(argp1);
32324 {
32325 PyThreadState* __tstate = wxPyBeginAllowThreads();
32326 (arg1)->InvalidateBestSize();
32327 wxPyEndAllowThreads(__tstate);
32328 if (PyErr_Occurred()) SWIG_fail;
32329 }
32330 resultobj = SWIG_Py_Void();
32331 return resultobj;
32332 fail:
32333 return NULL;
32334 }
32335
32336
32337 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32338 PyObject *resultobj = 0;
32339 wxWindow *arg1 = (wxWindow *) 0 ;
32340 wxSize *arg2 = 0 ;
32341 void *argp1 = 0 ;
32342 int res1 = 0 ;
32343 wxSize temp2 ;
32344 PyObject * obj0 = 0 ;
32345 PyObject * obj1 = 0 ;
32346 char * kwnames[] = {
32347 (char *) "self",(char *) "size", NULL
32348 };
32349
32350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32352 if (!SWIG_IsOK(res1)) {
32353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32354 }
32355 arg1 = reinterpret_cast< wxWindow * >(argp1);
32356 {
32357 arg2 = &temp2;
32358 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32359 }
32360 {
32361 PyThreadState* __tstate = wxPyBeginAllowThreads();
32362 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32363 wxPyEndAllowThreads(__tstate);
32364 if (PyErr_Occurred()) SWIG_fail;
32365 }
32366 resultobj = SWIG_Py_Void();
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32374 PyObject *resultobj = 0;
32375 wxWindow *arg1 = (wxWindow *) 0 ;
32376 wxSize result;
32377 void *argp1 = 0 ;
32378 int res1 = 0 ;
32379 PyObject *swig_obj[1] ;
32380
32381 if (!args) SWIG_fail;
32382 swig_obj[0] = args;
32383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32384 if (!SWIG_IsOK(res1)) {
32385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32386 }
32387 arg1 = reinterpret_cast< wxWindow * >(argp1);
32388 {
32389 PyThreadState* __tstate = wxPyBeginAllowThreads();
32390 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32391 wxPyEndAllowThreads(__tstate);
32392 if (PyErr_Occurred()) SWIG_fail;
32393 }
32394 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32395 return resultobj;
32396 fail:
32397 return NULL;
32398 }
32399
32400
32401 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32402 PyObject *resultobj = 0;
32403 wxWindow *arg1 = (wxWindow *) 0 ;
32404 wxSize result;
32405 void *argp1 = 0 ;
32406 int res1 = 0 ;
32407 PyObject *swig_obj[1] ;
32408
32409 if (!args) SWIG_fail;
32410 swig_obj[0] = args;
32411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32412 if (!SWIG_IsOK(res1)) {
32413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32414 }
32415 arg1 = reinterpret_cast< wxWindow * >(argp1);
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32423 return resultobj;
32424 fail:
32425 return NULL;
32426 }
32427
32428
32429 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32430 PyObject *resultobj = 0;
32431 wxWindow *arg1 = (wxWindow *) 0 ;
32432 int arg2 = (int) wxBOTH ;
32433 void *argp1 = 0 ;
32434 int res1 = 0 ;
32435 int val2 ;
32436 int ecode2 = 0 ;
32437 PyObject * obj0 = 0 ;
32438 PyObject * obj1 = 0 ;
32439 char * kwnames[] = {
32440 (char *) "self",(char *) "direction", NULL
32441 };
32442
32443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32445 if (!SWIG_IsOK(res1)) {
32446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32447 }
32448 arg1 = reinterpret_cast< wxWindow * >(argp1);
32449 if (obj1) {
32450 ecode2 = SWIG_AsVal_int(obj1, &val2);
32451 if (!SWIG_IsOK(ecode2)) {
32452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32453 }
32454 arg2 = static_cast< int >(val2);
32455 }
32456 {
32457 PyThreadState* __tstate = wxPyBeginAllowThreads();
32458 (arg1)->Center(arg2);
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 resultobj = SWIG_Py_Void();
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = 0;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 int arg2 = (int) wxBOTH ;
32473 void *argp1 = 0 ;
32474 int res1 = 0 ;
32475 int val2 ;
32476 int ecode2 = 0 ;
32477 PyObject * obj0 = 0 ;
32478 PyObject * obj1 = 0 ;
32479 char * kwnames[] = {
32480 (char *) "self",(char *) "dir", NULL
32481 };
32482
32483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32487 }
32488 arg1 = reinterpret_cast< wxWindow * >(argp1);
32489 if (obj1) {
32490 ecode2 = SWIG_AsVal_int(obj1, &val2);
32491 if (!SWIG_IsOK(ecode2)) {
32492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32493 }
32494 arg2 = static_cast< int >(val2);
32495 }
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 (arg1)->CenterOnParent(arg2);
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 resultobj = SWIG_Py_Void();
32503 return resultobj;
32504 fail:
32505 return NULL;
32506 }
32507
32508
32509 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32510 PyObject *resultobj = 0;
32511 wxWindow *arg1 = (wxWindow *) 0 ;
32512 void *argp1 = 0 ;
32513 int res1 = 0 ;
32514 PyObject *swig_obj[1] ;
32515
32516 if (!args) SWIG_fail;
32517 swig_obj[0] = args;
32518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32519 if (!SWIG_IsOK(res1)) {
32520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32521 }
32522 arg1 = reinterpret_cast< wxWindow * >(argp1);
32523 {
32524 PyThreadState* __tstate = wxPyBeginAllowThreads();
32525 (arg1)->Fit();
32526 wxPyEndAllowThreads(__tstate);
32527 if (PyErr_Occurred()) SWIG_fail;
32528 }
32529 resultobj = SWIG_Py_Void();
32530 return resultobj;
32531 fail:
32532 return NULL;
32533 }
32534
32535
32536 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32537 PyObject *resultobj = 0;
32538 wxWindow *arg1 = (wxWindow *) 0 ;
32539 void *argp1 = 0 ;
32540 int res1 = 0 ;
32541 PyObject *swig_obj[1] ;
32542
32543 if (!args) SWIG_fail;
32544 swig_obj[0] = args;
32545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32546 if (!SWIG_IsOK(res1)) {
32547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32548 }
32549 arg1 = reinterpret_cast< wxWindow * >(argp1);
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 (arg1)->FitInside();
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 resultobj = SWIG_Py_Void();
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32564 PyObject *resultobj = 0;
32565 wxWindow *arg1 = (wxWindow *) 0 ;
32566 int arg2 ;
32567 int arg3 ;
32568 int arg4 = (int) -1 ;
32569 int arg5 = (int) -1 ;
32570 int arg6 = (int) -1 ;
32571 int arg7 = (int) -1 ;
32572 void *argp1 = 0 ;
32573 int res1 = 0 ;
32574 int val2 ;
32575 int ecode2 = 0 ;
32576 int val3 ;
32577 int ecode3 = 0 ;
32578 int val4 ;
32579 int ecode4 = 0 ;
32580 int val5 ;
32581 int ecode5 = 0 ;
32582 int val6 ;
32583 int ecode6 = 0 ;
32584 int val7 ;
32585 int ecode7 = 0 ;
32586 PyObject * obj0 = 0 ;
32587 PyObject * obj1 = 0 ;
32588 PyObject * obj2 = 0 ;
32589 PyObject * obj3 = 0 ;
32590 PyObject * obj4 = 0 ;
32591 PyObject * obj5 = 0 ;
32592 PyObject * obj6 = 0 ;
32593 char * kwnames[] = {
32594 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32595 };
32596
32597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32599 if (!SWIG_IsOK(res1)) {
32600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32601 }
32602 arg1 = reinterpret_cast< wxWindow * >(argp1);
32603 ecode2 = SWIG_AsVal_int(obj1, &val2);
32604 if (!SWIG_IsOK(ecode2)) {
32605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32606 }
32607 arg2 = static_cast< int >(val2);
32608 ecode3 = SWIG_AsVal_int(obj2, &val3);
32609 if (!SWIG_IsOK(ecode3)) {
32610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32611 }
32612 arg3 = static_cast< int >(val3);
32613 if (obj3) {
32614 ecode4 = SWIG_AsVal_int(obj3, &val4);
32615 if (!SWIG_IsOK(ecode4)) {
32616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32617 }
32618 arg4 = static_cast< int >(val4);
32619 }
32620 if (obj4) {
32621 ecode5 = SWIG_AsVal_int(obj4, &val5);
32622 if (!SWIG_IsOK(ecode5)) {
32623 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32624 }
32625 arg5 = static_cast< int >(val5);
32626 }
32627 if (obj5) {
32628 ecode6 = SWIG_AsVal_int(obj5, &val6);
32629 if (!SWIG_IsOK(ecode6)) {
32630 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32631 }
32632 arg6 = static_cast< int >(val6);
32633 }
32634 if (obj6) {
32635 ecode7 = SWIG_AsVal_int(obj6, &val7);
32636 if (!SWIG_IsOK(ecode7)) {
32637 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32638 }
32639 arg7 = static_cast< int >(val7);
32640 }
32641 {
32642 PyThreadState* __tstate = wxPyBeginAllowThreads();
32643 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32644 wxPyEndAllowThreads(__tstate);
32645 if (PyErr_Occurred()) SWIG_fail;
32646 }
32647 resultobj = SWIG_Py_Void();
32648 return resultobj;
32649 fail:
32650 return NULL;
32651 }
32652
32653
32654 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32655 PyObject *resultobj = 0;
32656 wxWindow *arg1 = (wxWindow *) 0 ;
32657 wxSize *arg2 = 0 ;
32658 wxSize const &arg3_defvalue = wxDefaultSize ;
32659 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32660 wxSize const &arg4_defvalue = wxDefaultSize ;
32661 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32662 void *argp1 = 0 ;
32663 int res1 = 0 ;
32664 wxSize temp2 ;
32665 wxSize temp3 ;
32666 wxSize temp4 ;
32667 PyObject * obj0 = 0 ;
32668 PyObject * obj1 = 0 ;
32669 PyObject * obj2 = 0 ;
32670 PyObject * obj3 = 0 ;
32671 char * kwnames[] = {
32672 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32673 };
32674
32675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32679 }
32680 arg1 = reinterpret_cast< wxWindow * >(argp1);
32681 {
32682 arg2 = &temp2;
32683 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32684 }
32685 if (obj2) {
32686 {
32687 arg3 = &temp3;
32688 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32689 }
32690 }
32691 if (obj3) {
32692 {
32693 arg4 = &temp4;
32694 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32695 }
32696 }
32697 {
32698 PyThreadState* __tstate = wxPyBeginAllowThreads();
32699 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32700 wxPyEndAllowThreads(__tstate);
32701 if (PyErr_Occurred()) SWIG_fail;
32702 }
32703 resultobj = SWIG_Py_Void();
32704 return resultobj;
32705 fail:
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32711 PyObject *resultobj = 0;
32712 wxWindow *arg1 = (wxWindow *) 0 ;
32713 int arg2 ;
32714 int arg3 ;
32715 int arg4 = (int) -1 ;
32716 int arg5 = (int) -1 ;
32717 void *argp1 = 0 ;
32718 int res1 = 0 ;
32719 int val2 ;
32720 int ecode2 = 0 ;
32721 int val3 ;
32722 int ecode3 = 0 ;
32723 int val4 ;
32724 int ecode4 = 0 ;
32725 int val5 ;
32726 int ecode5 = 0 ;
32727 PyObject * obj0 = 0 ;
32728 PyObject * obj1 = 0 ;
32729 PyObject * obj2 = 0 ;
32730 PyObject * obj3 = 0 ;
32731 PyObject * obj4 = 0 ;
32732 char * kwnames[] = {
32733 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32734 };
32735
32736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32740 }
32741 arg1 = reinterpret_cast< wxWindow * >(argp1);
32742 ecode2 = SWIG_AsVal_int(obj1, &val2);
32743 if (!SWIG_IsOK(ecode2)) {
32744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32745 }
32746 arg2 = static_cast< int >(val2);
32747 ecode3 = SWIG_AsVal_int(obj2, &val3);
32748 if (!SWIG_IsOK(ecode3)) {
32749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32750 }
32751 arg3 = static_cast< int >(val3);
32752 if (obj3) {
32753 ecode4 = SWIG_AsVal_int(obj3, &val4);
32754 if (!SWIG_IsOK(ecode4)) {
32755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32756 }
32757 arg4 = static_cast< int >(val4);
32758 }
32759 if (obj4) {
32760 ecode5 = SWIG_AsVal_int(obj4, &val5);
32761 if (!SWIG_IsOK(ecode5)) {
32762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32763 }
32764 arg5 = static_cast< int >(val5);
32765 }
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_Py_Void();
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32780 PyObject *resultobj = 0;
32781 wxWindow *arg1 = (wxWindow *) 0 ;
32782 wxSize *arg2 = 0 ;
32783 wxSize const &arg3_defvalue = wxDefaultSize ;
32784 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32785 void *argp1 = 0 ;
32786 int res1 = 0 ;
32787 wxSize temp2 ;
32788 wxSize temp3 ;
32789 PyObject * obj0 = 0 ;
32790 PyObject * obj1 = 0 ;
32791 PyObject * obj2 = 0 ;
32792 char * kwnames[] = {
32793 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32794 };
32795
32796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32798 if (!SWIG_IsOK(res1)) {
32799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32800 }
32801 arg1 = reinterpret_cast< wxWindow * >(argp1);
32802 {
32803 arg2 = &temp2;
32804 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32805 }
32806 if (obj2) {
32807 {
32808 arg3 = &temp3;
32809 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32810 }
32811 }
32812 {
32813 PyThreadState* __tstate = wxPyBeginAllowThreads();
32814 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32815 wxPyEndAllowThreads(__tstate);
32816 if (PyErr_Occurred()) SWIG_fail;
32817 }
32818 resultobj = SWIG_Py_Void();
32819 return resultobj;
32820 fail:
32821 return NULL;
32822 }
32823
32824
32825 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32826 PyObject *resultobj = 0;
32827 wxWindow *arg1 = (wxWindow *) 0 ;
32828 wxSize result;
32829 void *argp1 = 0 ;
32830 int res1 = 0 ;
32831 PyObject *swig_obj[1] ;
32832
32833 if (!args) SWIG_fail;
32834 swig_obj[0] = args;
32835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32836 if (!SWIG_IsOK(res1)) {
32837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32838 }
32839 arg1 = reinterpret_cast< wxWindow * >(argp1);
32840 {
32841 PyThreadState* __tstate = wxPyBeginAllowThreads();
32842 result = ((wxWindow const *)arg1)->GetMaxSize();
32843 wxPyEndAllowThreads(__tstate);
32844 if (PyErr_Occurred()) SWIG_fail;
32845 }
32846 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32847 return resultobj;
32848 fail:
32849 return NULL;
32850 }
32851
32852
32853 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32854 PyObject *resultobj = 0;
32855 wxWindow *arg1 = (wxWindow *) 0 ;
32856 wxSize result;
32857 void *argp1 = 0 ;
32858 int res1 = 0 ;
32859 PyObject *swig_obj[1] ;
32860
32861 if (!args) SWIG_fail;
32862 swig_obj[0] = args;
32863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32864 if (!SWIG_IsOK(res1)) {
32865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32866 }
32867 arg1 = reinterpret_cast< wxWindow * >(argp1);
32868 {
32869 PyThreadState* __tstate = wxPyBeginAllowThreads();
32870 result = ((wxWindow const *)arg1)->GetMinSize();
32871 wxPyEndAllowThreads(__tstate);
32872 if (PyErr_Occurred()) SWIG_fail;
32873 }
32874 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32875 return resultobj;
32876 fail:
32877 return NULL;
32878 }
32879
32880
32881 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32882 PyObject *resultobj = 0;
32883 wxWindow *arg1 = (wxWindow *) 0 ;
32884 wxSize *arg2 = 0 ;
32885 void *argp1 = 0 ;
32886 int res1 = 0 ;
32887 wxSize temp2 ;
32888 PyObject * obj0 = 0 ;
32889 PyObject * obj1 = 0 ;
32890 char * kwnames[] = {
32891 (char *) "self",(char *) "minSize", NULL
32892 };
32893
32894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32896 if (!SWIG_IsOK(res1)) {
32897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32898 }
32899 arg1 = reinterpret_cast< wxWindow * >(argp1);
32900 {
32901 arg2 = &temp2;
32902 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32903 }
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 (arg1)->SetMinSize((wxSize const &)*arg2);
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 resultobj = SWIG_Py_Void();
32911 return resultobj;
32912 fail:
32913 return NULL;
32914 }
32915
32916
32917 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32918 PyObject *resultobj = 0;
32919 wxWindow *arg1 = (wxWindow *) 0 ;
32920 wxSize *arg2 = 0 ;
32921 void *argp1 = 0 ;
32922 int res1 = 0 ;
32923 wxSize temp2 ;
32924 PyObject * obj0 = 0 ;
32925 PyObject * obj1 = 0 ;
32926 char * kwnames[] = {
32927 (char *) "self",(char *) "maxSize", NULL
32928 };
32929
32930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32932 if (!SWIG_IsOK(res1)) {
32933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32934 }
32935 arg1 = reinterpret_cast< wxWindow * >(argp1);
32936 {
32937 arg2 = &temp2;
32938 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32939 }
32940 {
32941 PyThreadState* __tstate = wxPyBeginAllowThreads();
32942 (arg1)->SetMaxSize((wxSize const &)*arg2);
32943 wxPyEndAllowThreads(__tstate);
32944 if (PyErr_Occurred()) SWIG_fail;
32945 }
32946 resultobj = SWIG_Py_Void();
32947 return resultobj;
32948 fail:
32949 return NULL;
32950 }
32951
32952
32953 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32954 PyObject *resultobj = 0;
32955 wxWindow *arg1 = (wxWindow *) 0 ;
32956 int result;
32957 void *argp1 = 0 ;
32958 int res1 = 0 ;
32959 PyObject *swig_obj[1] ;
32960
32961 if (!args) SWIG_fail;
32962 swig_obj[0] = args;
32963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32964 if (!SWIG_IsOK(res1)) {
32965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32966 }
32967 arg1 = reinterpret_cast< wxWindow * >(argp1);
32968 {
32969 PyThreadState* __tstate = wxPyBeginAllowThreads();
32970 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32971 wxPyEndAllowThreads(__tstate);
32972 if (PyErr_Occurred()) SWIG_fail;
32973 }
32974 resultobj = SWIG_From_int(static_cast< int >(result));
32975 return resultobj;
32976 fail:
32977 return NULL;
32978 }
32979
32980
32981 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32982 PyObject *resultobj = 0;
32983 wxWindow *arg1 = (wxWindow *) 0 ;
32984 int result;
32985 void *argp1 = 0 ;
32986 int res1 = 0 ;
32987 PyObject *swig_obj[1] ;
32988
32989 if (!args) SWIG_fail;
32990 swig_obj[0] = args;
32991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32992 if (!SWIG_IsOK(res1)) {
32993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32994 }
32995 arg1 = reinterpret_cast< wxWindow * >(argp1);
32996 {
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 resultobj = SWIG_From_int(static_cast< int >(result));
33003 return resultobj;
33004 fail:
33005 return NULL;
33006 }
33007
33008
33009 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33010 PyObject *resultobj = 0;
33011 wxWindow *arg1 = (wxWindow *) 0 ;
33012 int result;
33013 void *argp1 = 0 ;
33014 int res1 = 0 ;
33015 PyObject *swig_obj[1] ;
33016
33017 if (!args) SWIG_fail;
33018 swig_obj[0] = args;
33019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33020 if (!SWIG_IsOK(res1)) {
33021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33022 }
33023 arg1 = reinterpret_cast< wxWindow * >(argp1);
33024 {
33025 PyThreadState* __tstate = wxPyBeginAllowThreads();
33026 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33027 wxPyEndAllowThreads(__tstate);
33028 if (PyErr_Occurred()) SWIG_fail;
33029 }
33030 resultobj = SWIG_From_int(static_cast< int >(result));
33031 return resultobj;
33032 fail:
33033 return NULL;
33034 }
33035
33036
33037 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33038 PyObject *resultobj = 0;
33039 wxWindow *arg1 = (wxWindow *) 0 ;
33040 int result;
33041 void *argp1 = 0 ;
33042 int res1 = 0 ;
33043 PyObject *swig_obj[1] ;
33044
33045 if (!args) SWIG_fail;
33046 swig_obj[0] = args;
33047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33048 if (!SWIG_IsOK(res1)) {
33049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33050 }
33051 arg1 = reinterpret_cast< wxWindow * >(argp1);
33052 {
33053 PyThreadState* __tstate = wxPyBeginAllowThreads();
33054 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33055 wxPyEndAllowThreads(__tstate);
33056 if (PyErr_Occurred()) SWIG_fail;
33057 }
33058 resultobj = SWIG_From_int(static_cast< int >(result));
33059 return resultobj;
33060 fail:
33061 return NULL;
33062 }
33063
33064
33065 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33066 PyObject *resultobj = 0;
33067 wxWindow *arg1 = (wxWindow *) 0 ;
33068 wxSize *arg2 = 0 ;
33069 void *argp1 = 0 ;
33070 int res1 = 0 ;
33071 wxSize temp2 ;
33072 PyObject * obj0 = 0 ;
33073 PyObject * obj1 = 0 ;
33074 char * kwnames[] = {
33075 (char *) "self",(char *) "size", NULL
33076 };
33077
33078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33080 if (!SWIG_IsOK(res1)) {
33081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33082 }
33083 arg1 = reinterpret_cast< wxWindow * >(argp1);
33084 {
33085 arg2 = &temp2;
33086 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33087 }
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33091 wxPyEndAllowThreads(__tstate);
33092 if (PyErr_Occurred()) SWIG_fail;
33093 }
33094 resultobj = SWIG_Py_Void();
33095 return resultobj;
33096 fail:
33097 return NULL;
33098 }
33099
33100
33101 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33102 PyObject *resultobj = 0;
33103 wxWindow *arg1 = (wxWindow *) 0 ;
33104 int arg2 ;
33105 int arg3 ;
33106 void *argp1 = 0 ;
33107 int res1 = 0 ;
33108 int val2 ;
33109 int ecode2 = 0 ;
33110 int val3 ;
33111 int ecode3 = 0 ;
33112 PyObject * obj0 = 0 ;
33113 PyObject * obj1 = 0 ;
33114 PyObject * obj2 = 0 ;
33115 char * kwnames[] = {
33116 (char *) "self",(char *) "w",(char *) "h", NULL
33117 };
33118
33119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33123 }
33124 arg1 = reinterpret_cast< wxWindow * >(argp1);
33125 ecode2 = SWIG_AsVal_int(obj1, &val2);
33126 if (!SWIG_IsOK(ecode2)) {
33127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33128 }
33129 arg2 = static_cast< int >(val2);
33130 ecode3 = SWIG_AsVal_int(obj2, &val3);
33131 if (!SWIG_IsOK(ecode3)) {
33132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33133 }
33134 arg3 = static_cast< int >(val3);
33135 {
33136 PyThreadState* __tstate = wxPyBeginAllowThreads();
33137 (arg1)->SetVirtualSize(arg2,arg3);
33138 wxPyEndAllowThreads(__tstate);
33139 if (PyErr_Occurred()) SWIG_fail;
33140 }
33141 resultobj = SWIG_Py_Void();
33142 return resultobj;
33143 fail:
33144 return NULL;
33145 }
33146
33147
33148 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33149 PyObject *resultobj = 0;
33150 wxWindow *arg1 = (wxWindow *) 0 ;
33151 wxSize result;
33152 void *argp1 = 0 ;
33153 int res1 = 0 ;
33154 PyObject *swig_obj[1] ;
33155
33156 if (!args) SWIG_fail;
33157 swig_obj[0] = args;
33158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33159 if (!SWIG_IsOK(res1)) {
33160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33161 }
33162 arg1 = reinterpret_cast< wxWindow * >(argp1);
33163 {
33164 PyThreadState* __tstate = wxPyBeginAllowThreads();
33165 result = ((wxWindow const *)arg1)->GetVirtualSize();
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33170 return resultobj;
33171 fail:
33172 return NULL;
33173 }
33174
33175
33176 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33177 PyObject *resultobj = 0;
33178 wxWindow *arg1 = (wxWindow *) 0 ;
33179 int *arg2 = (int *) 0 ;
33180 int *arg3 = (int *) 0 ;
33181 void *argp1 = 0 ;
33182 int res1 = 0 ;
33183 int temp2 ;
33184 int res2 = SWIG_TMPOBJ ;
33185 int temp3 ;
33186 int res3 = SWIG_TMPOBJ ;
33187 PyObject *swig_obj[1] ;
33188
33189 arg2 = &temp2;
33190 arg3 = &temp3;
33191 if (!args) SWIG_fail;
33192 swig_obj[0] = args;
33193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33194 if (!SWIG_IsOK(res1)) {
33195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33196 }
33197 arg1 = reinterpret_cast< wxWindow * >(argp1);
33198 {
33199 PyThreadState* __tstate = wxPyBeginAllowThreads();
33200 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33201 wxPyEndAllowThreads(__tstate);
33202 if (PyErr_Occurred()) SWIG_fail;
33203 }
33204 resultobj = SWIG_Py_Void();
33205 if (SWIG_IsTmpObj(res2)) {
33206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33207 } else {
33208 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33210 }
33211 if (SWIG_IsTmpObj(res3)) {
33212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33213 } else {
33214 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33216 }
33217 return resultobj;
33218 fail:
33219 return NULL;
33220 }
33221
33222
33223 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33224 PyObject *resultobj = 0;
33225 wxWindow *arg1 = (wxWindow *) 0 ;
33226 wxSize result;
33227 void *argp1 = 0 ;
33228 int res1 = 0 ;
33229 PyObject *swig_obj[1] ;
33230
33231 if (!args) SWIG_fail;
33232 swig_obj[0] = args;
33233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33234 if (!SWIG_IsOK(res1)) {
33235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33236 }
33237 arg1 = reinterpret_cast< wxWindow * >(argp1);
33238 {
33239 PyThreadState* __tstate = wxPyBeginAllowThreads();
33240 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33241 wxPyEndAllowThreads(__tstate);
33242 if (PyErr_Occurred()) SWIG_fail;
33243 }
33244 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33245 return resultobj;
33246 fail:
33247 return NULL;
33248 }
33249
33250
33251 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33252 PyObject *resultobj = 0;
33253 wxWindow *arg1 = (wxWindow *) 0 ;
33254 bool arg2 = (bool) true ;
33255 bool result;
33256 void *argp1 = 0 ;
33257 int res1 = 0 ;
33258 bool val2 ;
33259 int ecode2 = 0 ;
33260 PyObject * obj0 = 0 ;
33261 PyObject * obj1 = 0 ;
33262 char * kwnames[] = {
33263 (char *) "self",(char *) "show", NULL
33264 };
33265
33266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33268 if (!SWIG_IsOK(res1)) {
33269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33270 }
33271 arg1 = reinterpret_cast< wxWindow * >(argp1);
33272 if (obj1) {
33273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33274 if (!SWIG_IsOK(ecode2)) {
33275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33276 }
33277 arg2 = static_cast< bool >(val2);
33278 }
33279 {
33280 PyThreadState* __tstate = wxPyBeginAllowThreads();
33281 result = (bool)(arg1)->Show(arg2);
33282 wxPyEndAllowThreads(__tstate);
33283 if (PyErr_Occurred()) SWIG_fail;
33284 }
33285 {
33286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33287 }
33288 return resultobj;
33289 fail:
33290 return NULL;
33291 }
33292
33293
33294 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33295 PyObject *resultobj = 0;
33296 wxWindow *arg1 = (wxWindow *) 0 ;
33297 bool result;
33298 void *argp1 = 0 ;
33299 int res1 = 0 ;
33300 PyObject *swig_obj[1] ;
33301
33302 if (!args) SWIG_fail;
33303 swig_obj[0] = args;
33304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33305 if (!SWIG_IsOK(res1)) {
33306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33307 }
33308 arg1 = reinterpret_cast< wxWindow * >(argp1);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 result = (bool)(arg1)->Hide();
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 {
33316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33317 }
33318 return resultobj;
33319 fail:
33320 return NULL;
33321 }
33322
33323
33324 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33325 PyObject *resultobj = 0;
33326 wxWindow *arg1 = (wxWindow *) 0 ;
33327 bool arg2 = (bool) true ;
33328 bool result;
33329 void *argp1 = 0 ;
33330 int res1 = 0 ;
33331 bool val2 ;
33332 int ecode2 = 0 ;
33333 PyObject * obj0 = 0 ;
33334 PyObject * obj1 = 0 ;
33335 char * kwnames[] = {
33336 (char *) "self",(char *) "enable", NULL
33337 };
33338
33339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33341 if (!SWIG_IsOK(res1)) {
33342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33343 }
33344 arg1 = reinterpret_cast< wxWindow * >(argp1);
33345 if (obj1) {
33346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33347 if (!SWIG_IsOK(ecode2)) {
33348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33349 }
33350 arg2 = static_cast< bool >(val2);
33351 }
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 result = (bool)(arg1)->Enable(arg2);
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 {
33359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33360 }
33361 return resultobj;
33362 fail:
33363 return NULL;
33364 }
33365
33366
33367 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33368 PyObject *resultobj = 0;
33369 wxWindow *arg1 = (wxWindow *) 0 ;
33370 bool result;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 PyObject *swig_obj[1] ;
33374
33375 if (!args) SWIG_fail;
33376 swig_obj[0] = args;
33377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33378 if (!SWIG_IsOK(res1)) {
33379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33380 }
33381 arg1 = reinterpret_cast< wxWindow * >(argp1);
33382 {
33383 PyThreadState* __tstate = wxPyBeginAllowThreads();
33384 result = (bool)(arg1)->Disable();
33385 wxPyEndAllowThreads(__tstate);
33386 if (PyErr_Occurred()) SWIG_fail;
33387 }
33388 {
33389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33390 }
33391 return resultobj;
33392 fail:
33393 return NULL;
33394 }
33395
33396
33397 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33398 PyObject *resultobj = 0;
33399 wxWindow *arg1 = (wxWindow *) 0 ;
33400 bool result;
33401 void *argp1 = 0 ;
33402 int res1 = 0 ;
33403 PyObject *swig_obj[1] ;
33404
33405 if (!args) SWIG_fail;
33406 swig_obj[0] = args;
33407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33408 if (!SWIG_IsOK(res1)) {
33409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33410 }
33411 arg1 = reinterpret_cast< wxWindow * >(argp1);
33412 {
33413 PyThreadState* __tstate = wxPyBeginAllowThreads();
33414 result = (bool)((wxWindow const *)arg1)->IsShown();
33415 wxPyEndAllowThreads(__tstate);
33416 if (PyErr_Occurred()) SWIG_fail;
33417 }
33418 {
33419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33420 }
33421 return resultobj;
33422 fail:
33423 return NULL;
33424 }
33425
33426
33427 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33428 PyObject *resultobj = 0;
33429 wxWindow *arg1 = (wxWindow *) 0 ;
33430 bool result;
33431 void *argp1 = 0 ;
33432 int res1 = 0 ;
33433 PyObject *swig_obj[1] ;
33434
33435 if (!args) SWIG_fail;
33436 swig_obj[0] = args;
33437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33438 if (!SWIG_IsOK(res1)) {
33439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33440 }
33441 arg1 = reinterpret_cast< wxWindow * >(argp1);
33442 {
33443 PyThreadState* __tstate = wxPyBeginAllowThreads();
33444 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33445 wxPyEndAllowThreads(__tstate);
33446 if (PyErr_Occurred()) SWIG_fail;
33447 }
33448 {
33449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33450 }
33451 return resultobj;
33452 fail:
33453 return NULL;
33454 }
33455
33456
33457 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33458 PyObject *resultobj = 0;
33459 wxWindow *arg1 = (wxWindow *) 0 ;
33460 bool result;
33461 void *argp1 = 0 ;
33462 int res1 = 0 ;
33463 PyObject *swig_obj[1] ;
33464
33465 if (!args) SWIG_fail;
33466 swig_obj[0] = args;
33467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33468 if (!SWIG_IsOK(res1)) {
33469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33470 }
33471 arg1 = reinterpret_cast< wxWindow * >(argp1);
33472 {
33473 PyThreadState* __tstate = wxPyBeginAllowThreads();
33474 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33475 wxPyEndAllowThreads(__tstate);
33476 if (PyErr_Occurred()) SWIG_fail;
33477 }
33478 {
33479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33480 }
33481 return resultobj;
33482 fail:
33483 return NULL;
33484 }
33485
33486
33487 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33488 PyObject *resultobj = 0;
33489 wxWindow *arg1 = (wxWindow *) 0 ;
33490 long arg2 ;
33491 void *argp1 = 0 ;
33492 int res1 = 0 ;
33493 long val2 ;
33494 int ecode2 = 0 ;
33495 PyObject * obj0 = 0 ;
33496 PyObject * obj1 = 0 ;
33497 char * kwnames[] = {
33498 (char *) "self",(char *) "style", NULL
33499 };
33500
33501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33503 if (!SWIG_IsOK(res1)) {
33504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33505 }
33506 arg1 = reinterpret_cast< wxWindow * >(argp1);
33507 ecode2 = SWIG_AsVal_long(obj1, &val2);
33508 if (!SWIG_IsOK(ecode2)) {
33509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33510 }
33511 arg2 = static_cast< long >(val2);
33512 {
33513 PyThreadState* __tstate = wxPyBeginAllowThreads();
33514 (arg1)->SetWindowStyleFlag(arg2);
33515 wxPyEndAllowThreads(__tstate);
33516 if (PyErr_Occurred()) SWIG_fail;
33517 }
33518 resultobj = SWIG_Py_Void();
33519 return resultobj;
33520 fail:
33521 return NULL;
33522 }
33523
33524
33525 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33526 PyObject *resultobj = 0;
33527 wxWindow *arg1 = (wxWindow *) 0 ;
33528 long result;
33529 void *argp1 = 0 ;
33530 int res1 = 0 ;
33531 PyObject *swig_obj[1] ;
33532
33533 if (!args) SWIG_fail;
33534 swig_obj[0] = args;
33535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33536 if (!SWIG_IsOK(res1)) {
33537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33538 }
33539 arg1 = reinterpret_cast< wxWindow * >(argp1);
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 resultobj = SWIG_From_long(static_cast< long >(result));
33547 return resultobj;
33548 fail:
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 int arg2 ;
33557 bool result;
33558 void *argp1 = 0 ;
33559 int res1 = 0 ;
33560 int val2 ;
33561 int ecode2 = 0 ;
33562 PyObject * obj0 = 0 ;
33563 PyObject * obj1 = 0 ;
33564 char * kwnames[] = {
33565 (char *) "self",(char *) "flag", NULL
33566 };
33567
33568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33570 if (!SWIG_IsOK(res1)) {
33571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33572 }
33573 arg1 = reinterpret_cast< wxWindow * >(argp1);
33574 ecode2 = SWIG_AsVal_int(obj1, &val2);
33575 if (!SWIG_IsOK(ecode2)) {
33576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33577 }
33578 arg2 = static_cast< int >(val2);
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 {
33586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33587 }
33588 return resultobj;
33589 fail:
33590 return NULL;
33591 }
33592
33593
33594 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33595 PyObject *resultobj = 0;
33596 wxWindow *arg1 = (wxWindow *) 0 ;
33597 bool result;
33598 void *argp1 = 0 ;
33599 int res1 = 0 ;
33600 PyObject *swig_obj[1] ;
33601
33602 if (!args) SWIG_fail;
33603 swig_obj[0] = args;
33604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33605 if (!SWIG_IsOK(res1)) {
33606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33607 }
33608 arg1 = reinterpret_cast< wxWindow * >(argp1);
33609 {
33610 PyThreadState* __tstate = wxPyBeginAllowThreads();
33611 result = (bool)((wxWindow const *)arg1)->IsRetained();
33612 wxPyEndAllowThreads(__tstate);
33613 if (PyErr_Occurred()) SWIG_fail;
33614 }
33615 {
33616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33617 }
33618 return resultobj;
33619 fail:
33620 return NULL;
33621 }
33622
33623
33624 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33625 PyObject *resultobj = 0;
33626 wxWindow *arg1 = (wxWindow *) 0 ;
33627 long arg2 ;
33628 void *argp1 = 0 ;
33629 int res1 = 0 ;
33630 long val2 ;
33631 int ecode2 = 0 ;
33632 PyObject * obj0 = 0 ;
33633 PyObject * obj1 = 0 ;
33634 char * kwnames[] = {
33635 (char *) "self",(char *) "exStyle", NULL
33636 };
33637
33638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33640 if (!SWIG_IsOK(res1)) {
33641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33642 }
33643 arg1 = reinterpret_cast< wxWindow * >(argp1);
33644 ecode2 = SWIG_AsVal_long(obj1, &val2);
33645 if (!SWIG_IsOK(ecode2)) {
33646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33647 }
33648 arg2 = static_cast< long >(val2);
33649 {
33650 PyThreadState* __tstate = wxPyBeginAllowThreads();
33651 (arg1)->SetExtraStyle(arg2);
33652 wxPyEndAllowThreads(__tstate);
33653 if (PyErr_Occurred()) SWIG_fail;
33654 }
33655 resultobj = SWIG_Py_Void();
33656 return resultobj;
33657 fail:
33658 return NULL;
33659 }
33660
33661
33662 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33663 PyObject *resultobj = 0;
33664 wxWindow *arg1 = (wxWindow *) 0 ;
33665 long result;
33666 void *argp1 = 0 ;
33667 int res1 = 0 ;
33668 PyObject *swig_obj[1] ;
33669
33670 if (!args) SWIG_fail;
33671 swig_obj[0] = args;
33672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 {
33678 PyThreadState* __tstate = wxPyBeginAllowThreads();
33679 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33680 wxPyEndAllowThreads(__tstate);
33681 if (PyErr_Occurred()) SWIG_fail;
33682 }
33683 resultobj = SWIG_From_long(static_cast< long >(result));
33684 return resultobj;
33685 fail:
33686 return NULL;
33687 }
33688
33689
33690 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33691 PyObject *resultobj = 0;
33692 wxWindow *arg1 = (wxWindow *) 0 ;
33693 bool arg2 = (bool) true ;
33694 void *argp1 = 0 ;
33695 int res1 = 0 ;
33696 bool val2 ;
33697 int ecode2 = 0 ;
33698 PyObject * obj0 = 0 ;
33699 PyObject * obj1 = 0 ;
33700 char * kwnames[] = {
33701 (char *) "self",(char *) "modal", NULL
33702 };
33703
33704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33706 if (!SWIG_IsOK(res1)) {
33707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33708 }
33709 arg1 = reinterpret_cast< wxWindow * >(argp1);
33710 if (obj1) {
33711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33712 if (!SWIG_IsOK(ecode2)) {
33713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33714 }
33715 arg2 = static_cast< bool >(val2);
33716 }
33717 {
33718 PyThreadState* __tstate = wxPyBeginAllowThreads();
33719 (arg1)->MakeModal(arg2);
33720 wxPyEndAllowThreads(__tstate);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 }
33723 resultobj = SWIG_Py_Void();
33724 return resultobj;
33725 fail:
33726 return NULL;
33727 }
33728
33729
33730 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33731 PyObject *resultobj = 0;
33732 wxWindow *arg1 = (wxWindow *) 0 ;
33733 bool arg2 ;
33734 void *argp1 = 0 ;
33735 int res1 = 0 ;
33736 bool val2 ;
33737 int ecode2 = 0 ;
33738 PyObject * obj0 = 0 ;
33739 PyObject * obj1 = 0 ;
33740 char * kwnames[] = {
33741 (char *) "self",(char *) "enableTheme", NULL
33742 };
33743
33744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33746 if (!SWIG_IsOK(res1)) {
33747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33748 }
33749 arg1 = reinterpret_cast< wxWindow * >(argp1);
33750 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33751 if (!SWIG_IsOK(ecode2)) {
33752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33753 }
33754 arg2 = static_cast< bool >(val2);
33755 {
33756 PyThreadState* __tstate = wxPyBeginAllowThreads();
33757 (arg1)->SetThemeEnabled(arg2);
33758 wxPyEndAllowThreads(__tstate);
33759 if (PyErr_Occurred()) SWIG_fail;
33760 }
33761 resultobj = SWIG_Py_Void();
33762 return resultobj;
33763 fail:
33764 return NULL;
33765 }
33766
33767
33768 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33769 PyObject *resultobj = 0;
33770 wxWindow *arg1 = (wxWindow *) 0 ;
33771 bool result;
33772 void *argp1 = 0 ;
33773 int res1 = 0 ;
33774 PyObject *swig_obj[1] ;
33775
33776 if (!args) SWIG_fail;
33777 swig_obj[0] = args;
33778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33779 if (!SWIG_IsOK(res1)) {
33780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33781 }
33782 arg1 = reinterpret_cast< wxWindow * >(argp1);
33783 {
33784 PyThreadState* __tstate = wxPyBeginAllowThreads();
33785 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33786 wxPyEndAllowThreads(__tstate);
33787 if (PyErr_Occurred()) SWIG_fail;
33788 }
33789 {
33790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33791 }
33792 return resultobj;
33793 fail:
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33799 PyObject *resultobj = 0;
33800 wxWindow *arg1 = (wxWindow *) 0 ;
33801 void *argp1 = 0 ;
33802 int res1 = 0 ;
33803 PyObject *swig_obj[1] ;
33804
33805 if (!args) SWIG_fail;
33806 swig_obj[0] = args;
33807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33808 if (!SWIG_IsOK(res1)) {
33809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33810 }
33811 arg1 = reinterpret_cast< wxWindow * >(argp1);
33812 {
33813 PyThreadState* __tstate = wxPyBeginAllowThreads();
33814 (arg1)->SetFocus();
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 resultobj = SWIG_Py_Void();
33819 return resultobj;
33820 fail:
33821 return NULL;
33822 }
33823
33824
33825 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33826 PyObject *resultobj = 0;
33827 wxWindow *arg1 = (wxWindow *) 0 ;
33828 void *argp1 = 0 ;
33829 int res1 = 0 ;
33830 PyObject *swig_obj[1] ;
33831
33832 if (!args) SWIG_fail;
33833 swig_obj[0] = args;
33834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33835 if (!SWIG_IsOK(res1)) {
33836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33837 }
33838 arg1 = reinterpret_cast< wxWindow * >(argp1);
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 (arg1)->SetFocusFromKbd();
33842 wxPyEndAllowThreads(__tstate);
33843 if (PyErr_Occurred()) SWIG_fail;
33844 }
33845 resultobj = SWIG_Py_Void();
33846 return resultobj;
33847 fail:
33848 return NULL;
33849 }
33850
33851
33852 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33853 PyObject *resultobj = 0;
33854 wxWindow *result = 0 ;
33855
33856 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33857 {
33858 if (!wxPyCheckForApp()) SWIG_fail;
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 result = (wxWindow *)wxWindow::FindFocus();
33861 wxPyEndAllowThreads(__tstate);
33862 if (PyErr_Occurred()) SWIG_fail;
33863 }
33864 {
33865 resultobj = wxPyMake_wxObject(result, 0);
33866 }
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 bool result;
33877 void *argp1 = 0 ;
33878 int res1 = 0 ;
33879 PyObject *swig_obj[1] ;
33880
33881 if (!args) SWIG_fail;
33882 swig_obj[0] = args;
33883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33886 }
33887 arg1 = reinterpret_cast< wxWindow * >(argp1);
33888 {
33889 PyThreadState* __tstate = wxPyBeginAllowThreads();
33890 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 {
33895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33896 }
33897 return resultobj;
33898 fail:
33899 return NULL;
33900 }
33901
33902
33903 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33904 PyObject *resultobj = 0;
33905 wxWindow *arg1 = (wxWindow *) 0 ;
33906 bool result;
33907 void *argp1 = 0 ;
33908 int res1 = 0 ;
33909 PyObject *swig_obj[1] ;
33910
33911 if (!args) SWIG_fail;
33912 swig_obj[0] = args;
33913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33916 }
33917 arg1 = reinterpret_cast< wxWindow * >(argp1);
33918 {
33919 PyThreadState* __tstate = wxPyBeginAllowThreads();
33920 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33921 wxPyEndAllowThreads(__tstate);
33922 if (PyErr_Occurred()) SWIG_fail;
33923 }
33924 {
33925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33926 }
33927 return resultobj;
33928 fail:
33929 return NULL;
33930 }
33931
33932
33933 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33934 PyObject *resultobj = 0;
33935 wxWindow *arg1 = (wxWindow *) 0 ;
33936 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33937 bool result;
33938 void *argp1 = 0 ;
33939 int res1 = 0 ;
33940 int val2 ;
33941 int ecode2 = 0 ;
33942 PyObject * obj0 = 0 ;
33943 PyObject * obj1 = 0 ;
33944 char * kwnames[] = {
33945 (char *) "self",(char *) "flags", NULL
33946 };
33947
33948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33950 if (!SWIG_IsOK(res1)) {
33951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33952 }
33953 arg1 = reinterpret_cast< wxWindow * >(argp1);
33954 if (obj1) {
33955 ecode2 = SWIG_AsVal_int(obj1, &val2);
33956 if (!SWIG_IsOK(ecode2)) {
33957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33958 }
33959 arg2 = static_cast< int >(val2);
33960 }
33961 {
33962 PyThreadState* __tstate = wxPyBeginAllowThreads();
33963 result = (bool)(arg1)->Navigate(arg2);
33964 wxPyEndAllowThreads(__tstate);
33965 if (PyErr_Occurred()) SWIG_fail;
33966 }
33967 {
33968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33969 }
33970 return resultobj;
33971 fail:
33972 return NULL;
33973 }
33974
33975
33976 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33977 PyObject *resultobj = 0;
33978 wxWindow *arg1 = (wxWindow *) 0 ;
33979 wxWindow *arg2 = (wxWindow *) 0 ;
33980 void *argp1 = 0 ;
33981 int res1 = 0 ;
33982 void *argp2 = 0 ;
33983 int res2 = 0 ;
33984 PyObject * obj0 = 0 ;
33985 PyObject * obj1 = 0 ;
33986 char * kwnames[] = {
33987 (char *) "self",(char *) "win", NULL
33988 };
33989
33990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33992 if (!SWIG_IsOK(res1)) {
33993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33994 }
33995 arg1 = reinterpret_cast< wxWindow * >(argp1);
33996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33997 if (!SWIG_IsOK(res2)) {
33998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33999 }
34000 arg2 = reinterpret_cast< wxWindow * >(argp2);
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 (arg1)->MoveAfterInTabOrder(arg2);
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_Py_Void();
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 wxWindow *arg2 = (wxWindow *) 0 ;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 void *argp2 = 0 ;
34021 int res2 = 0 ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char * kwnames[] = {
34025 (char *) "self",(char *) "win", NULL
34026 };
34027
34028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34030 if (!SWIG_IsOK(res1)) {
34031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34032 }
34033 arg1 = reinterpret_cast< wxWindow * >(argp1);
34034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34035 if (!SWIG_IsOK(res2)) {
34036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34037 }
34038 arg2 = reinterpret_cast< wxWindow * >(argp2);
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 (arg1)->MoveBeforeInTabOrder(arg2);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 resultobj = SWIG_Py_Void();
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34053 PyObject *resultobj = 0;
34054 wxWindow *arg1 = (wxWindow *) 0 ;
34055 PyObject *result = 0 ;
34056 void *argp1 = 0 ;
34057 int res1 = 0 ;
34058 PyObject *swig_obj[1] ;
34059
34060 if (!args) SWIG_fail;
34061 swig_obj[0] = args;
34062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 result = (PyObject *)wxWindow_GetChildren(arg1);
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = result;
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34081 PyObject *resultobj = 0;
34082 wxWindow *arg1 = (wxWindow *) 0 ;
34083 wxWindow *result = 0 ;
34084 void *argp1 = 0 ;
34085 int res1 = 0 ;
34086 PyObject *swig_obj[1] ;
34087
34088 if (!args) SWIG_fail;
34089 swig_obj[0] = args;
34090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34091 if (!SWIG_IsOK(res1)) {
34092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34093 }
34094 arg1 = reinterpret_cast< wxWindow * >(argp1);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 {
34102 resultobj = wxPyMake_wxObject(result, 0);
34103 }
34104 return resultobj;
34105 fail:
34106 return NULL;
34107 }
34108
34109
34110 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34111 PyObject *resultobj = 0;
34112 wxWindow *arg1 = (wxWindow *) 0 ;
34113 wxWindow *result = 0 ;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 PyObject *swig_obj[1] ;
34117
34118 if (!args) SWIG_fail;
34119 swig_obj[0] = args;
34120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34121 if (!SWIG_IsOK(res1)) {
34122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34123 }
34124 arg1 = reinterpret_cast< wxWindow * >(argp1);
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 {
34132 resultobj = wxPyMake_wxObject(result, 0);
34133 }
34134 return resultobj;
34135 fail:
34136 return NULL;
34137 }
34138
34139
34140 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34141 PyObject *resultobj = 0;
34142 wxWindow *arg1 = (wxWindow *) 0 ;
34143 bool result;
34144 void *argp1 = 0 ;
34145 int res1 = 0 ;
34146 PyObject *swig_obj[1] ;
34147
34148 if (!args) SWIG_fail;
34149 swig_obj[0] = args;
34150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34151 if (!SWIG_IsOK(res1)) {
34152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34153 }
34154 arg1 = reinterpret_cast< wxWindow * >(argp1);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 {
34162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34163 }
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj = 0;
34172 wxWindow *arg1 = (wxWindow *) 0 ;
34173 wxWindow *arg2 = (wxWindow *) 0 ;
34174 bool result;
34175 void *argp1 = 0 ;
34176 int res1 = 0 ;
34177 void *argp2 = 0 ;
34178 int res2 = 0 ;
34179 PyObject * obj0 = 0 ;
34180 PyObject * obj1 = 0 ;
34181 char * kwnames[] = {
34182 (char *) "self",(char *) "newParent", NULL
34183 };
34184
34185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34187 if (!SWIG_IsOK(res1)) {
34188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34189 }
34190 arg1 = reinterpret_cast< wxWindow * >(argp1);
34191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34192 if (!SWIG_IsOK(res2)) {
34193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34194 }
34195 arg2 = reinterpret_cast< wxWindow * >(argp2);
34196 {
34197 PyThreadState* __tstate = wxPyBeginAllowThreads();
34198 result = (bool)(arg1)->Reparent(arg2);
34199 wxPyEndAllowThreads(__tstate);
34200 if (PyErr_Occurred()) SWIG_fail;
34201 }
34202 {
34203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34204 }
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 wxWindow *arg2 = (wxWindow *) 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 void *argp2 = 0 ;
34218 int res2 = 0 ;
34219 PyObject * obj0 = 0 ;
34220 PyObject * obj1 = 0 ;
34221 char * kwnames[] = {
34222 (char *) "self",(char *) "child", NULL
34223 };
34224
34225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34227 if (!SWIG_IsOK(res1)) {
34228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34229 }
34230 arg1 = reinterpret_cast< wxWindow * >(argp1);
34231 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34232 if (!SWIG_IsOK(res2)) {
34233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34234 }
34235 arg2 = reinterpret_cast< wxWindow * >(argp2);
34236 {
34237 PyThreadState* __tstate = wxPyBeginAllowThreads();
34238 (arg1)->AddChild(arg2);
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 resultobj = SWIG_Py_Void();
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34250 PyObject *resultobj = 0;
34251 wxWindow *arg1 = (wxWindow *) 0 ;
34252 wxWindow *arg2 = (wxWindow *) 0 ;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 void *argp2 = 0 ;
34256 int res2 = 0 ;
34257 PyObject * obj0 = 0 ;
34258 PyObject * obj1 = 0 ;
34259 char * kwnames[] = {
34260 (char *) "self",(char *) "child", NULL
34261 };
34262
34263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34265 if (!SWIG_IsOK(res1)) {
34266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34267 }
34268 arg1 = reinterpret_cast< wxWindow * >(argp1);
34269 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34270 if (!SWIG_IsOK(res2)) {
34271 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34272 }
34273 arg2 = reinterpret_cast< wxWindow * >(argp2);
34274 {
34275 PyThreadState* __tstate = wxPyBeginAllowThreads();
34276 (arg1)->RemoveChild(arg2);
34277 wxPyEndAllowThreads(__tstate);
34278 if (PyErr_Occurred()) SWIG_fail;
34279 }
34280 resultobj = SWIG_Py_Void();
34281 return resultobj;
34282 fail:
34283 return NULL;
34284 }
34285
34286
34287 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34288 PyObject *resultobj = 0;
34289 wxWindow *arg1 = (wxWindow *) 0 ;
34290 bool arg2 ;
34291 void *argp1 = 0 ;
34292 int res1 = 0 ;
34293 bool val2 ;
34294 int ecode2 = 0 ;
34295 PyObject * obj0 = 0 ;
34296 PyObject * obj1 = 0 ;
34297 char * kwnames[] = {
34298 (char *) "self",(char *) "on", NULL
34299 };
34300
34301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34303 if (!SWIG_IsOK(res1)) {
34304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34305 }
34306 arg1 = reinterpret_cast< wxWindow * >(argp1);
34307 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34308 if (!SWIG_IsOK(ecode2)) {
34309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34310 }
34311 arg2 = static_cast< bool >(val2);
34312 {
34313 PyThreadState* __tstate = wxPyBeginAllowThreads();
34314 wxWindow_SetDoubleBuffered(arg1,arg2);
34315 wxPyEndAllowThreads(__tstate);
34316 if (PyErr_Occurred()) SWIG_fail;
34317 }
34318 resultobj = SWIG_Py_Void();
34319 return resultobj;
34320 fail:
34321 return NULL;
34322 }
34323
34324
34325 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34326 PyObject *resultobj = 0;
34327 wxWindow *arg1 = (wxWindow *) 0 ;
34328 long arg2 ;
34329 wxWindow *result = 0 ;
34330 void *argp1 = 0 ;
34331 int res1 = 0 ;
34332 long val2 ;
34333 int ecode2 = 0 ;
34334 PyObject * obj0 = 0 ;
34335 PyObject * obj1 = 0 ;
34336 char * kwnames[] = {
34337 (char *) "self",(char *) "winid", NULL
34338 };
34339
34340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 ecode2 = SWIG_AsVal_long(obj1, &val2);
34347 if (!SWIG_IsOK(ecode2)) {
34348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34349 }
34350 arg2 = static_cast< long >(val2);
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 result = (wxWindow *)(arg1)->FindWindow(arg2);
34354 wxPyEndAllowThreads(__tstate);
34355 if (PyErr_Occurred()) SWIG_fail;
34356 }
34357 {
34358 resultobj = wxPyMake_wxObject(result, 0);
34359 }
34360 return resultobj;
34361 fail:
34362 return NULL;
34363 }
34364
34365
34366 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34367 PyObject *resultobj = 0;
34368 wxWindow *arg1 = (wxWindow *) 0 ;
34369 wxString *arg2 = 0 ;
34370 wxWindow *result = 0 ;
34371 void *argp1 = 0 ;
34372 int res1 = 0 ;
34373 bool temp2 = false ;
34374 PyObject * obj0 = 0 ;
34375 PyObject * obj1 = 0 ;
34376 char * kwnames[] = {
34377 (char *) "self",(char *) "name", NULL
34378 };
34379
34380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34382 if (!SWIG_IsOK(res1)) {
34383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34384 }
34385 arg1 = reinterpret_cast< wxWindow * >(argp1);
34386 {
34387 arg2 = wxString_in_helper(obj1);
34388 if (arg2 == NULL) SWIG_fail;
34389 temp2 = true;
34390 }
34391 {
34392 PyThreadState* __tstate = wxPyBeginAllowThreads();
34393 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 {
34398 resultobj = wxPyMake_wxObject(result, 0);
34399 }
34400 {
34401 if (temp2)
34402 delete arg2;
34403 }
34404 return resultobj;
34405 fail:
34406 {
34407 if (temp2)
34408 delete arg2;
34409 }
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 wxEvtHandler *result = 0 ;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 {
34436 resultobj = wxPyMake_wxObject(result, 0);
34437 }
34438 return resultobj;
34439 fail:
34440 return NULL;
34441 }
34442
34443
34444 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34445 PyObject *resultobj = 0;
34446 wxWindow *arg1 = (wxWindow *) 0 ;
34447 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 void *argp2 = 0 ;
34451 int res2 = 0 ;
34452 PyObject * obj0 = 0 ;
34453 PyObject * obj1 = 0 ;
34454 char * kwnames[] = {
34455 (char *) "self",(char *) "handler", NULL
34456 };
34457
34458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34460 if (!SWIG_IsOK(res1)) {
34461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34462 }
34463 arg1 = reinterpret_cast< wxWindow * >(argp1);
34464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34465 if (!SWIG_IsOK(res2)) {
34466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34467 }
34468 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34469 {
34470 PyThreadState* __tstate = wxPyBeginAllowThreads();
34471 (arg1)->SetEventHandler(arg2);
34472 wxPyEndAllowThreads(__tstate);
34473 if (PyErr_Occurred()) SWIG_fail;
34474 }
34475 resultobj = SWIG_Py_Void();
34476 return resultobj;
34477 fail:
34478 return NULL;
34479 }
34480
34481
34482 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34483 PyObject *resultobj = 0;
34484 wxWindow *arg1 = (wxWindow *) 0 ;
34485 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34486 void *argp1 = 0 ;
34487 int res1 = 0 ;
34488 void *argp2 = 0 ;
34489 int res2 = 0 ;
34490 PyObject * obj0 = 0 ;
34491 PyObject * obj1 = 0 ;
34492 char * kwnames[] = {
34493 (char *) "self",(char *) "handler", NULL
34494 };
34495
34496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34498 if (!SWIG_IsOK(res1)) {
34499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34500 }
34501 arg1 = reinterpret_cast< wxWindow * >(argp1);
34502 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34503 if (!SWIG_IsOK(res2)) {
34504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34505 }
34506 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34507 {
34508 PyThreadState* __tstate = wxPyBeginAllowThreads();
34509 (arg1)->PushEventHandler(arg2);
34510 wxPyEndAllowThreads(__tstate);
34511 if (PyErr_Occurred()) SWIG_fail;
34512 }
34513 resultobj = SWIG_Py_Void();
34514 return resultobj;
34515 fail:
34516 return NULL;
34517 }
34518
34519
34520 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34521 PyObject *resultobj = 0;
34522 wxWindow *arg1 = (wxWindow *) 0 ;
34523 bool arg2 = (bool) false ;
34524 wxEvtHandler *result = 0 ;
34525 void *argp1 = 0 ;
34526 int res1 = 0 ;
34527 bool val2 ;
34528 int ecode2 = 0 ;
34529 PyObject * obj0 = 0 ;
34530 PyObject * obj1 = 0 ;
34531 char * kwnames[] = {
34532 (char *) "self",(char *) "deleteHandler", NULL
34533 };
34534
34535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34537 if (!SWIG_IsOK(res1)) {
34538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34539 }
34540 arg1 = reinterpret_cast< wxWindow * >(argp1);
34541 if (obj1) {
34542 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34543 if (!SWIG_IsOK(ecode2)) {
34544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34545 }
34546 arg2 = static_cast< bool >(val2);
34547 }
34548 {
34549 PyThreadState* __tstate = wxPyBeginAllowThreads();
34550 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34551 wxPyEndAllowThreads(__tstate);
34552 if (PyErr_Occurred()) SWIG_fail;
34553 }
34554 {
34555 resultobj = wxPyMake_wxObject(result, 0);
34556 }
34557 return resultobj;
34558 fail:
34559 return NULL;
34560 }
34561
34562
34563 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34564 PyObject *resultobj = 0;
34565 wxWindow *arg1 = (wxWindow *) 0 ;
34566 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34567 bool result;
34568 void *argp1 = 0 ;
34569 int res1 = 0 ;
34570 void *argp2 = 0 ;
34571 int res2 = 0 ;
34572 PyObject * obj0 = 0 ;
34573 PyObject * obj1 = 0 ;
34574 char * kwnames[] = {
34575 (char *) "self",(char *) "handler", NULL
34576 };
34577
34578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34580 if (!SWIG_IsOK(res1)) {
34581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34582 }
34583 arg1 = reinterpret_cast< wxWindow * >(argp1);
34584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34585 if (!SWIG_IsOK(res2)) {
34586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34587 }
34588 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34589 {
34590 PyThreadState* __tstate = wxPyBeginAllowThreads();
34591 result = (bool)(arg1)->RemoveEventHandler(arg2);
34592 wxPyEndAllowThreads(__tstate);
34593 if (PyErr_Occurred()) SWIG_fail;
34594 }
34595 {
34596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34597 }
34598 return resultobj;
34599 fail:
34600 return NULL;
34601 }
34602
34603
34604 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34605 PyObject *resultobj = 0;
34606 wxWindow *arg1 = (wxWindow *) 0 ;
34607 wxValidator *arg2 = 0 ;
34608 void *argp1 = 0 ;
34609 int res1 = 0 ;
34610 void *argp2 = 0 ;
34611 int res2 = 0 ;
34612 PyObject * obj0 = 0 ;
34613 PyObject * obj1 = 0 ;
34614 char * kwnames[] = {
34615 (char *) "self",(char *) "validator", NULL
34616 };
34617
34618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34625 if (!SWIG_IsOK(res2)) {
34626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34627 }
34628 if (!argp2) {
34629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34630 }
34631 arg2 = reinterpret_cast< wxValidator * >(argp2);
34632 {
34633 PyThreadState* __tstate = wxPyBeginAllowThreads();
34634 (arg1)->SetValidator((wxValidator const &)*arg2);
34635 wxPyEndAllowThreads(__tstate);
34636 if (PyErr_Occurred()) SWIG_fail;
34637 }
34638 resultobj = SWIG_Py_Void();
34639 return resultobj;
34640 fail:
34641 return NULL;
34642 }
34643
34644
34645 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34646 PyObject *resultobj = 0;
34647 wxWindow *arg1 = (wxWindow *) 0 ;
34648 wxValidator *result = 0 ;
34649 void *argp1 = 0 ;
34650 int res1 = 0 ;
34651 PyObject *swig_obj[1] ;
34652
34653 if (!args) SWIG_fail;
34654 swig_obj[0] = args;
34655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34656 if (!SWIG_IsOK(res1)) {
34657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34658 }
34659 arg1 = reinterpret_cast< wxWindow * >(argp1);
34660 {
34661 PyThreadState* __tstate = wxPyBeginAllowThreads();
34662 result = (wxValidator *)(arg1)->GetValidator();
34663 wxPyEndAllowThreads(__tstate);
34664 if (PyErr_Occurred()) SWIG_fail;
34665 }
34666 {
34667 resultobj = wxPyMake_wxObject(result, (bool)0);
34668 }
34669 return resultobj;
34670 fail:
34671 return NULL;
34672 }
34673
34674
34675 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34676 PyObject *resultobj = 0;
34677 wxWindow *arg1 = (wxWindow *) 0 ;
34678 bool result;
34679 void *argp1 = 0 ;
34680 int res1 = 0 ;
34681 PyObject *swig_obj[1] ;
34682
34683 if (!args) SWIG_fail;
34684 swig_obj[0] = args;
34685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34686 if (!SWIG_IsOK(res1)) {
34687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34688 }
34689 arg1 = reinterpret_cast< wxWindow * >(argp1);
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 result = (bool)(arg1)->Validate();
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 {
34697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34698 }
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34706 PyObject *resultobj = 0;
34707 wxWindow *arg1 = (wxWindow *) 0 ;
34708 bool result;
34709 void *argp1 = 0 ;
34710 int res1 = 0 ;
34711 PyObject *swig_obj[1] ;
34712
34713 if (!args) SWIG_fail;
34714 swig_obj[0] = args;
34715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34716 if (!SWIG_IsOK(res1)) {
34717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34718 }
34719 arg1 = reinterpret_cast< wxWindow * >(argp1);
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = (bool)(arg1)->TransferDataToWindow();
34723 wxPyEndAllowThreads(__tstate);
34724 if (PyErr_Occurred()) SWIG_fail;
34725 }
34726 {
34727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34728 }
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34736 PyObject *resultobj = 0;
34737 wxWindow *arg1 = (wxWindow *) 0 ;
34738 bool result;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 PyObject *swig_obj[1] ;
34742
34743 if (!args) SWIG_fail;
34744 swig_obj[0] = args;
34745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34746 if (!SWIG_IsOK(res1)) {
34747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34748 }
34749 arg1 = reinterpret_cast< wxWindow * >(argp1);
34750 {
34751 PyThreadState* __tstate = wxPyBeginAllowThreads();
34752 result = (bool)(arg1)->TransferDataFromWindow();
34753 wxPyEndAllowThreads(__tstate);
34754 if (PyErr_Occurred()) SWIG_fail;
34755 }
34756 {
34757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34758 }
34759 return resultobj;
34760 fail:
34761 return NULL;
34762 }
34763
34764
34765 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34766 PyObject *resultobj = 0;
34767 wxWindow *arg1 = (wxWindow *) 0 ;
34768 void *argp1 = 0 ;
34769 int res1 = 0 ;
34770 PyObject *swig_obj[1] ;
34771
34772 if (!args) SWIG_fail;
34773 swig_obj[0] = args;
34774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34775 if (!SWIG_IsOK(res1)) {
34776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34777 }
34778 arg1 = reinterpret_cast< wxWindow * >(argp1);
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 (arg1)->InitDialog();
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 resultobj = SWIG_Py_Void();
34786 return resultobj;
34787 fail:
34788 return NULL;
34789 }
34790
34791
34792 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj = 0;
34794 wxWindow *arg1 = (wxWindow *) 0 ;
34795 wxAcceleratorTable *arg2 = 0 ;
34796 void *argp1 = 0 ;
34797 int res1 = 0 ;
34798 void *argp2 = 0 ;
34799 int res2 = 0 ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 char * kwnames[] = {
34803 (char *) "self",(char *) "accel", NULL
34804 };
34805
34806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34808 if (!SWIG_IsOK(res1)) {
34809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34810 }
34811 arg1 = reinterpret_cast< wxWindow * >(argp1);
34812 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34813 if (!SWIG_IsOK(res2)) {
34814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34815 }
34816 if (!argp2) {
34817 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34818 }
34819 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34820 {
34821 PyThreadState* __tstate = wxPyBeginAllowThreads();
34822 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 resultobj = SWIG_Py_Void();
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 wxAcceleratorTable *result = 0 ;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 PyObject *swig_obj[1] ;
34840
34841 if (!args) SWIG_fail;
34842 swig_obj[0] = args;
34843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34862 PyObject *resultobj = 0;
34863 wxWindow *arg1 = (wxWindow *) 0 ;
34864 int arg2 ;
34865 int arg3 ;
34866 int arg4 ;
34867 bool result;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 int val2 ;
34871 int ecode2 = 0 ;
34872 int val3 ;
34873 int ecode3 = 0 ;
34874 int val4 ;
34875 int ecode4 = 0 ;
34876 PyObject * obj0 = 0 ;
34877 PyObject * obj1 = 0 ;
34878 PyObject * obj2 = 0 ;
34879 PyObject * obj3 = 0 ;
34880 char * kwnames[] = {
34881 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34882 };
34883
34884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34886 if (!SWIG_IsOK(res1)) {
34887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34888 }
34889 arg1 = reinterpret_cast< wxWindow * >(argp1);
34890 ecode2 = SWIG_AsVal_int(obj1, &val2);
34891 if (!SWIG_IsOK(ecode2)) {
34892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34893 }
34894 arg2 = static_cast< int >(val2);
34895 ecode3 = SWIG_AsVal_int(obj2, &val3);
34896 if (!SWIG_IsOK(ecode3)) {
34897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34898 }
34899 arg3 = static_cast< int >(val3);
34900 ecode4 = SWIG_AsVal_int(obj3, &val4);
34901 if (!SWIG_IsOK(ecode4)) {
34902 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34903 }
34904 arg4 = static_cast< int >(val4);
34905 {
34906 PyThreadState* __tstate = wxPyBeginAllowThreads();
34907 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34908 wxPyEndAllowThreads(__tstate);
34909 if (PyErr_Occurred()) SWIG_fail;
34910 }
34911 {
34912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34913 }
34914 return resultobj;
34915 fail:
34916 return NULL;
34917 }
34918
34919
34920 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34921 PyObject *resultobj = 0;
34922 wxWindow *arg1 = (wxWindow *) 0 ;
34923 int arg2 ;
34924 bool result;
34925 void *argp1 = 0 ;
34926 int res1 = 0 ;
34927 int val2 ;
34928 int ecode2 = 0 ;
34929 PyObject * obj0 = 0 ;
34930 PyObject * obj1 = 0 ;
34931 char * kwnames[] = {
34932 (char *) "self",(char *) "hotkeyId", NULL
34933 };
34934
34935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34937 if (!SWIG_IsOK(res1)) {
34938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34939 }
34940 arg1 = reinterpret_cast< wxWindow * >(argp1);
34941 ecode2 = SWIG_AsVal_int(obj1, &val2);
34942 if (!SWIG_IsOK(ecode2)) {
34943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34944 }
34945 arg2 = static_cast< int >(val2);
34946 {
34947 PyThreadState* __tstate = wxPyBeginAllowThreads();
34948 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34949 wxPyEndAllowThreads(__tstate);
34950 if (PyErr_Occurred()) SWIG_fail;
34951 }
34952 {
34953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34954 }
34955 return resultobj;
34956 fail:
34957 return NULL;
34958 }
34959
34960
34961 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34962 PyObject *resultobj = 0;
34963 wxWindow *arg1 = (wxWindow *) 0 ;
34964 wxPoint *arg2 = 0 ;
34965 wxPoint result;
34966 void *argp1 = 0 ;
34967 int res1 = 0 ;
34968 wxPoint temp2 ;
34969 PyObject * obj0 = 0 ;
34970 PyObject * obj1 = 0 ;
34971 char * kwnames[] = {
34972 (char *) "self",(char *) "pt", NULL
34973 };
34974
34975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34977 if (!SWIG_IsOK(res1)) {
34978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34979 }
34980 arg1 = reinterpret_cast< wxWindow * >(argp1);
34981 {
34982 arg2 = &temp2;
34983 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34984 }
34985 {
34986 PyThreadState* __tstate = wxPyBeginAllowThreads();
34987 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34988 wxPyEndAllowThreads(__tstate);
34989 if (PyErr_Occurred()) SWIG_fail;
34990 }
34991 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34992 return resultobj;
34993 fail:
34994 return NULL;
34995 }
34996
34997
34998 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34999 PyObject *resultobj = 0;
35000 wxWindow *arg1 = (wxWindow *) 0 ;
35001 wxSize *arg2 = 0 ;
35002 wxSize result;
35003 void *argp1 = 0 ;
35004 int res1 = 0 ;
35005 wxSize temp2 ;
35006 PyObject * obj0 = 0 ;
35007 PyObject * obj1 = 0 ;
35008 char * kwnames[] = {
35009 (char *) "self",(char *) "sz", NULL
35010 };
35011
35012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35014 if (!SWIG_IsOK(res1)) {
35015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35016 }
35017 arg1 = reinterpret_cast< wxWindow * >(argp1);
35018 {
35019 arg2 = &temp2;
35020 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35021 }
35022 {
35023 PyThreadState* __tstate = wxPyBeginAllowThreads();
35024 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35025 wxPyEndAllowThreads(__tstate);
35026 if (PyErr_Occurred()) SWIG_fail;
35027 }
35028 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 wxPoint *arg2 = 0 ;
35039 wxPoint result;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 wxPoint temp2 ;
35043 PyObject * obj0 = 0 ;
35044 PyObject * obj1 = 0 ;
35045 char * kwnames[] = {
35046 (char *) "self",(char *) "pt", NULL
35047 };
35048
35049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35053 }
35054 arg1 = reinterpret_cast< wxWindow * >(argp1);
35055 {
35056 arg2 = &temp2;
35057 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35058 }
35059 {
35060 PyThreadState* __tstate = wxPyBeginAllowThreads();
35061 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 wxSize *arg2 = 0 ;
35076 wxSize result;
35077 void *argp1 = 0 ;
35078 int res1 = 0 ;
35079 wxSize temp2 ;
35080 PyObject * obj0 = 0 ;
35081 PyObject * obj1 = 0 ;
35082 char * kwnames[] = {
35083 (char *) "self",(char *) "sz", NULL
35084 };
35085
35086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35088 if (!SWIG_IsOK(res1)) {
35089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35090 }
35091 arg1 = reinterpret_cast< wxWindow * >(argp1);
35092 {
35093 arg2 = &temp2;
35094 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35095 }
35096 {
35097 PyThreadState* __tstate = wxPyBeginAllowThreads();
35098 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35099 wxPyEndAllowThreads(__tstate);
35100 if (PyErr_Occurred()) SWIG_fail;
35101 }
35102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35103 return resultobj;
35104 fail:
35105 return NULL;
35106 }
35107
35108
35109 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj = 0;
35111 wxWindow *arg1 = (wxWindow *) 0 ;
35112 wxPoint *arg2 = 0 ;
35113 wxPoint result;
35114 void *argp1 = 0 ;
35115 int res1 = 0 ;
35116 wxPoint temp2 ;
35117 PyObject * obj0 = 0 ;
35118 PyObject * obj1 = 0 ;
35119 char * kwnames[] = {
35120 (char *) "self",(char *) "pt", NULL
35121 };
35122
35123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35125 if (!SWIG_IsOK(res1)) {
35126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35127 }
35128 arg1 = reinterpret_cast< wxWindow * >(argp1);
35129 {
35130 arg2 = &temp2;
35131 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35132 }
35133 {
35134 PyThreadState* __tstate = wxPyBeginAllowThreads();
35135 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35136 wxPyEndAllowThreads(__tstate);
35137 if (PyErr_Occurred()) SWIG_fail;
35138 }
35139 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35140 return resultobj;
35141 fail:
35142 return NULL;
35143 }
35144
35145
35146 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35147 PyObject *resultobj = 0;
35148 wxWindow *arg1 = (wxWindow *) 0 ;
35149 wxSize *arg2 = 0 ;
35150 wxSize result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 wxSize temp2 ;
35154 PyObject * obj0 = 0 ;
35155 PyObject * obj1 = 0 ;
35156 char * kwnames[] = {
35157 (char *) "self",(char *) "sz", NULL
35158 };
35159
35160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35162 if (!SWIG_IsOK(res1)) {
35163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35164 }
35165 arg1 = reinterpret_cast< wxWindow * >(argp1);
35166 {
35167 arg2 = &temp2;
35168 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35169 }
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35177 return resultobj;
35178 fail:
35179 return NULL;
35180 }
35181
35182
35183 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35184 PyObject *resultobj = 0;
35185 wxWindow *arg1 = (wxWindow *) 0 ;
35186 int arg2 ;
35187 int arg3 ;
35188 void *argp1 = 0 ;
35189 int res1 = 0 ;
35190 int val2 ;
35191 int ecode2 = 0 ;
35192 int val3 ;
35193 int ecode3 = 0 ;
35194 PyObject * obj0 = 0 ;
35195 PyObject * obj1 = 0 ;
35196 PyObject * obj2 = 0 ;
35197 char * kwnames[] = {
35198 (char *) "self",(char *) "x",(char *) "y", NULL
35199 };
35200
35201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 ecode2 = SWIG_AsVal_int(obj1, &val2);
35208 if (!SWIG_IsOK(ecode2)) {
35209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35210 }
35211 arg2 = static_cast< int >(val2);
35212 ecode3 = SWIG_AsVal_int(obj2, &val3);
35213 if (!SWIG_IsOK(ecode3)) {
35214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35215 }
35216 arg3 = static_cast< int >(val3);
35217 {
35218 PyThreadState* __tstate = wxPyBeginAllowThreads();
35219 (arg1)->WarpPointer(arg2,arg3);
35220 wxPyEndAllowThreads(__tstate);
35221 if (PyErr_Occurred()) SWIG_fail;
35222 }
35223 resultobj = SWIG_Py_Void();
35224 return resultobj;
35225 fail:
35226 return NULL;
35227 }
35228
35229
35230 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35231 PyObject *resultobj = 0;
35232 wxWindow *arg1 = (wxWindow *) 0 ;
35233 void *argp1 = 0 ;
35234 int res1 = 0 ;
35235 PyObject *swig_obj[1] ;
35236
35237 if (!args) SWIG_fail;
35238 swig_obj[0] = args;
35239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35240 if (!SWIG_IsOK(res1)) {
35241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35242 }
35243 arg1 = reinterpret_cast< wxWindow * >(argp1);
35244 {
35245 PyThreadState* __tstate = wxPyBeginAllowThreads();
35246 (arg1)->CaptureMouse();
35247 wxPyEndAllowThreads(__tstate);
35248 if (PyErr_Occurred()) SWIG_fail;
35249 }
35250 resultobj = SWIG_Py_Void();
35251 return resultobj;
35252 fail:
35253 return NULL;
35254 }
35255
35256
35257 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35258 PyObject *resultobj = 0;
35259 wxWindow *arg1 = (wxWindow *) 0 ;
35260 void *argp1 = 0 ;
35261 int res1 = 0 ;
35262 PyObject *swig_obj[1] ;
35263
35264 if (!args) SWIG_fail;
35265 swig_obj[0] = args;
35266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35267 if (!SWIG_IsOK(res1)) {
35268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35269 }
35270 arg1 = reinterpret_cast< wxWindow * >(argp1);
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 (arg1)->ReleaseMouse();
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 resultobj = SWIG_Py_Void();
35278 return resultobj;
35279 fail:
35280 return NULL;
35281 }
35282
35283
35284 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35285 PyObject *resultobj = 0;
35286 wxWindow *result = 0 ;
35287
35288 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35289 {
35290 if (!wxPyCheckForApp()) SWIG_fail;
35291 PyThreadState* __tstate = wxPyBeginAllowThreads();
35292 result = (wxWindow *)wxWindow::GetCapture();
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 {
35297 resultobj = wxPyMake_wxObject(result, 0);
35298 }
35299 return resultobj;
35300 fail:
35301 return NULL;
35302 }
35303
35304
35305 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35306 PyObject *resultobj = 0;
35307 wxWindow *arg1 = (wxWindow *) 0 ;
35308 bool result;
35309 void *argp1 = 0 ;
35310 int res1 = 0 ;
35311 PyObject *swig_obj[1] ;
35312
35313 if (!args) SWIG_fail;
35314 swig_obj[0] = args;
35315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35316 if (!SWIG_IsOK(res1)) {
35317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35318 }
35319 arg1 = reinterpret_cast< wxWindow * >(argp1);
35320 {
35321 PyThreadState* __tstate = wxPyBeginAllowThreads();
35322 result = (bool)((wxWindow const *)arg1)->HasCapture();
35323 wxPyEndAllowThreads(__tstate);
35324 if (PyErr_Occurred()) SWIG_fail;
35325 }
35326 {
35327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35328 }
35329 return resultobj;
35330 fail:
35331 return NULL;
35332 }
35333
35334
35335 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35336 PyObject *resultobj = 0;
35337 wxWindow *arg1 = (wxWindow *) 0 ;
35338 bool arg2 = (bool) true ;
35339 wxRect *arg3 = (wxRect *) NULL ;
35340 void *argp1 = 0 ;
35341 int res1 = 0 ;
35342 bool val2 ;
35343 int ecode2 = 0 ;
35344 void *argp3 = 0 ;
35345 int res3 = 0 ;
35346 PyObject * obj0 = 0 ;
35347 PyObject * obj1 = 0 ;
35348 PyObject * obj2 = 0 ;
35349 char * kwnames[] = {
35350 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35351 };
35352
35353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35355 if (!SWIG_IsOK(res1)) {
35356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35357 }
35358 arg1 = reinterpret_cast< wxWindow * >(argp1);
35359 if (obj1) {
35360 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35361 if (!SWIG_IsOK(ecode2)) {
35362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35363 }
35364 arg2 = static_cast< bool >(val2);
35365 }
35366 if (obj2) {
35367 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35368 if (!SWIG_IsOK(res3)) {
35369 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35370 }
35371 arg3 = reinterpret_cast< wxRect * >(argp3);
35372 }
35373 {
35374 PyThreadState* __tstate = wxPyBeginAllowThreads();
35375 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35376 wxPyEndAllowThreads(__tstate);
35377 if (PyErr_Occurred()) SWIG_fail;
35378 }
35379 resultobj = SWIG_Py_Void();
35380 return resultobj;
35381 fail:
35382 return NULL;
35383 }
35384
35385
35386 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35387 PyObject *resultobj = 0;
35388 wxWindow *arg1 = (wxWindow *) 0 ;
35389 wxRect *arg2 = 0 ;
35390 bool arg3 = (bool) true ;
35391 void *argp1 = 0 ;
35392 int res1 = 0 ;
35393 wxRect temp2 ;
35394 bool val3 ;
35395 int ecode3 = 0 ;
35396 PyObject * obj0 = 0 ;
35397 PyObject * obj1 = 0 ;
35398 PyObject * obj2 = 0 ;
35399 char * kwnames[] = {
35400 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35401 };
35402
35403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35405 if (!SWIG_IsOK(res1)) {
35406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35407 }
35408 arg1 = reinterpret_cast< wxWindow * >(argp1);
35409 {
35410 arg2 = &temp2;
35411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35412 }
35413 if (obj2) {
35414 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35415 if (!SWIG_IsOK(ecode3)) {
35416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35417 }
35418 arg3 = static_cast< bool >(val3);
35419 }
35420 {
35421 PyThreadState* __tstate = wxPyBeginAllowThreads();
35422 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35423 wxPyEndAllowThreads(__tstate);
35424 if (PyErr_Occurred()) SWIG_fail;
35425 }
35426 resultobj = SWIG_Py_Void();
35427 return resultobj;
35428 fail:
35429 return NULL;
35430 }
35431
35432
35433 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35434 PyObject *resultobj = 0;
35435 wxWindow *arg1 = (wxWindow *) 0 ;
35436 void *argp1 = 0 ;
35437 int res1 = 0 ;
35438 PyObject *swig_obj[1] ;
35439
35440 if (!args) SWIG_fail;
35441 swig_obj[0] = args;
35442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35443 if (!SWIG_IsOK(res1)) {
35444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35445 }
35446 arg1 = reinterpret_cast< wxWindow * >(argp1);
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 (arg1)->Update();
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 resultobj = SWIG_Py_Void();
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35461 PyObject *resultobj = 0;
35462 wxWindow *arg1 = (wxWindow *) 0 ;
35463 void *argp1 = 0 ;
35464 int res1 = 0 ;
35465 PyObject *swig_obj[1] ;
35466
35467 if (!args) SWIG_fail;
35468 swig_obj[0] = args;
35469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35470 if (!SWIG_IsOK(res1)) {
35471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35472 }
35473 arg1 = reinterpret_cast< wxWindow * >(argp1);
35474 {
35475 PyThreadState* __tstate = wxPyBeginAllowThreads();
35476 (arg1)->ClearBackground();
35477 wxPyEndAllowThreads(__tstate);
35478 if (PyErr_Occurred()) SWIG_fail;
35479 }
35480 resultobj = SWIG_Py_Void();
35481 return resultobj;
35482 fail:
35483 return NULL;
35484 }
35485
35486
35487 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35488 PyObject *resultobj = 0;
35489 wxWindow *arg1 = (wxWindow *) 0 ;
35490 void *argp1 = 0 ;
35491 int res1 = 0 ;
35492 PyObject *swig_obj[1] ;
35493
35494 if (!args) SWIG_fail;
35495 swig_obj[0] = args;
35496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35497 if (!SWIG_IsOK(res1)) {
35498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35499 }
35500 arg1 = reinterpret_cast< wxWindow * >(argp1);
35501 {
35502 PyThreadState* __tstate = wxPyBeginAllowThreads();
35503 (arg1)->Freeze();
35504 wxPyEndAllowThreads(__tstate);
35505 if (PyErr_Occurred()) SWIG_fail;
35506 }
35507 resultobj = SWIG_Py_Void();
35508 return resultobj;
35509 fail:
35510 return NULL;
35511 }
35512
35513
35514 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35515 PyObject *resultobj = 0;
35516 wxWindow *arg1 = (wxWindow *) 0 ;
35517 bool result;
35518 void *argp1 = 0 ;
35519 int res1 = 0 ;
35520 PyObject *swig_obj[1] ;
35521
35522 if (!args) SWIG_fail;
35523 swig_obj[0] = args;
35524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35525 if (!SWIG_IsOK(res1)) {
35526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35527 }
35528 arg1 = reinterpret_cast< wxWindow * >(argp1);
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35532 wxPyEndAllowThreads(__tstate);
35533 if (PyErr_Occurred()) SWIG_fail;
35534 }
35535 {
35536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35537 }
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35545 PyObject *resultobj = 0;
35546 wxWindow *arg1 = (wxWindow *) 0 ;
35547 void *argp1 = 0 ;
35548 int res1 = 0 ;
35549 PyObject *swig_obj[1] ;
35550
35551 if (!args) SWIG_fail;
35552 swig_obj[0] = args;
35553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35554 if (!SWIG_IsOK(res1)) {
35555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35556 }
35557 arg1 = reinterpret_cast< wxWindow * >(argp1);
35558 {
35559 PyThreadState* __tstate = wxPyBeginAllowThreads();
35560 (arg1)->Thaw();
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 resultobj = SWIG_Py_Void();
35565 return resultobj;
35566 fail:
35567 return NULL;
35568 }
35569
35570
35571 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35572 PyObject *resultobj = 0;
35573 wxWindow *arg1 = (wxWindow *) 0 ;
35574 wxDC *arg2 = 0 ;
35575 void *argp1 = 0 ;
35576 int res1 = 0 ;
35577 void *argp2 = 0 ;
35578 int res2 = 0 ;
35579 PyObject * obj0 = 0 ;
35580 PyObject * obj1 = 0 ;
35581 char * kwnames[] = {
35582 (char *) "self",(char *) "dc", NULL
35583 };
35584
35585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35587 if (!SWIG_IsOK(res1)) {
35588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35589 }
35590 arg1 = reinterpret_cast< wxWindow * >(argp1);
35591 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35592 if (!SWIG_IsOK(res2)) {
35593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35594 }
35595 if (!argp2) {
35596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35597 }
35598 arg2 = reinterpret_cast< wxDC * >(argp2);
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 (arg1)->PrepareDC(*arg2);
35602 wxPyEndAllowThreads(__tstate);
35603 if (PyErr_Occurred()) SWIG_fail;
35604 }
35605 resultobj = SWIG_Py_Void();
35606 return resultobj;
35607 fail:
35608 return NULL;
35609 }
35610
35611
35612 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35613 PyObject *resultobj = 0;
35614 wxWindow *arg1 = (wxWindow *) 0 ;
35615 wxRegion *result = 0 ;
35616 void *argp1 = 0 ;
35617 int res1 = 0 ;
35618 PyObject *swig_obj[1] ;
35619
35620 if (!args) SWIG_fail;
35621 swig_obj[0] = args;
35622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35623 if (!SWIG_IsOK(res1)) {
35624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35625 }
35626 arg1 = reinterpret_cast< wxWindow * >(argp1);
35627 {
35628 PyThreadState* __tstate = wxPyBeginAllowThreads();
35629 {
35630 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35631 result = (wxRegion *) &_result_ref;
35632 }
35633 wxPyEndAllowThreads(__tstate);
35634 if (PyErr_Occurred()) SWIG_fail;
35635 }
35636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35637 return resultobj;
35638 fail:
35639 return NULL;
35640 }
35641
35642
35643 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35644 PyObject *resultobj = 0;
35645 wxWindow *arg1 = (wxWindow *) 0 ;
35646 wxRect result;
35647 void *argp1 = 0 ;
35648 int res1 = 0 ;
35649 PyObject *swig_obj[1] ;
35650
35651 if (!args) SWIG_fail;
35652 swig_obj[0] = args;
35653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35654 if (!SWIG_IsOK(res1)) {
35655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35656 }
35657 arg1 = reinterpret_cast< wxWindow * >(argp1);
35658 {
35659 PyThreadState* __tstate = wxPyBeginAllowThreads();
35660 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35661 wxPyEndAllowThreads(__tstate);
35662 if (PyErr_Occurred()) SWIG_fail;
35663 }
35664 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35672 PyObject *resultobj = 0;
35673 wxWindow *arg1 = (wxWindow *) 0 ;
35674 int arg2 ;
35675 int arg3 ;
35676 int arg4 = (int) 1 ;
35677 int arg5 = (int) 1 ;
35678 bool result;
35679 void *argp1 = 0 ;
35680 int res1 = 0 ;
35681 int val2 ;
35682 int ecode2 = 0 ;
35683 int val3 ;
35684 int ecode3 = 0 ;
35685 int val4 ;
35686 int ecode4 = 0 ;
35687 int val5 ;
35688 int ecode5 = 0 ;
35689 PyObject * obj0 = 0 ;
35690 PyObject * obj1 = 0 ;
35691 PyObject * obj2 = 0 ;
35692 PyObject * obj3 = 0 ;
35693 PyObject * obj4 = 0 ;
35694 char * kwnames[] = {
35695 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35696 };
35697
35698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35700 if (!SWIG_IsOK(res1)) {
35701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35702 }
35703 arg1 = reinterpret_cast< wxWindow * >(argp1);
35704 ecode2 = SWIG_AsVal_int(obj1, &val2);
35705 if (!SWIG_IsOK(ecode2)) {
35706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35707 }
35708 arg2 = static_cast< int >(val2);
35709 ecode3 = SWIG_AsVal_int(obj2, &val3);
35710 if (!SWIG_IsOK(ecode3)) {
35711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35712 }
35713 arg3 = static_cast< int >(val3);
35714 if (obj3) {
35715 ecode4 = SWIG_AsVal_int(obj3, &val4);
35716 if (!SWIG_IsOK(ecode4)) {
35717 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35718 }
35719 arg4 = static_cast< int >(val4);
35720 }
35721 if (obj4) {
35722 ecode5 = SWIG_AsVal_int(obj4, &val5);
35723 if (!SWIG_IsOK(ecode5)) {
35724 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35725 }
35726 arg5 = static_cast< int >(val5);
35727 }
35728 {
35729 PyThreadState* __tstate = wxPyBeginAllowThreads();
35730 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35731 wxPyEndAllowThreads(__tstate);
35732 if (PyErr_Occurred()) SWIG_fail;
35733 }
35734 {
35735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35736 }
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35744 PyObject *resultobj = 0;
35745 wxWindow *arg1 = (wxWindow *) 0 ;
35746 wxPoint *arg2 = 0 ;
35747 bool result;
35748 void *argp1 = 0 ;
35749 int res1 = 0 ;
35750 wxPoint temp2 ;
35751 PyObject * obj0 = 0 ;
35752 PyObject * obj1 = 0 ;
35753 char * kwnames[] = {
35754 (char *) "self",(char *) "pt", NULL
35755 };
35756
35757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35759 if (!SWIG_IsOK(res1)) {
35760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35761 }
35762 arg1 = reinterpret_cast< wxWindow * >(argp1);
35763 {
35764 arg2 = &temp2;
35765 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35766 }
35767 {
35768 PyThreadState* __tstate = wxPyBeginAllowThreads();
35769 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35770 wxPyEndAllowThreads(__tstate);
35771 if (PyErr_Occurred()) SWIG_fail;
35772 }
35773 {
35774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35775 }
35776 return resultobj;
35777 fail:
35778 return NULL;
35779 }
35780
35781
35782 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35783 PyObject *resultobj = 0;
35784 wxWindow *arg1 = (wxWindow *) 0 ;
35785 wxRect *arg2 = 0 ;
35786 bool result;
35787 void *argp1 = 0 ;
35788 int res1 = 0 ;
35789 wxRect temp2 ;
35790 PyObject * obj0 = 0 ;
35791 PyObject * obj1 = 0 ;
35792 char * kwnames[] = {
35793 (char *) "self",(char *) "rect", NULL
35794 };
35795
35796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35798 if (!SWIG_IsOK(res1)) {
35799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35800 }
35801 arg1 = reinterpret_cast< wxWindow * >(argp1);
35802 {
35803 arg2 = &temp2;
35804 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35805 }
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 {
35813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35814 }
35815 return resultobj;
35816 fail:
35817 return NULL;
35818 }
35819
35820
35821 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35822 PyObject *resultobj = 0;
35823 wxWindow *arg1 = (wxWindow *) 0 ;
35824 SwigValueWrapper<wxVisualAttributes > result;
35825 void *argp1 = 0 ;
35826 int res1 = 0 ;
35827 PyObject *swig_obj[1] ;
35828
35829 if (!args) SWIG_fail;
35830 swig_obj[0] = args;
35831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35832 if (!SWIG_IsOK(res1)) {
35833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35834 }
35835 arg1 = reinterpret_cast< wxWindow * >(argp1);
35836 {
35837 PyThreadState* __tstate = wxPyBeginAllowThreads();
35838 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35839 wxPyEndAllowThreads(__tstate);
35840 if (PyErr_Occurred()) SWIG_fail;
35841 }
35842 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35843 return resultobj;
35844 fail:
35845 return NULL;
35846 }
35847
35848
35849 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35850 PyObject *resultobj = 0;
35851 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35852 SwigValueWrapper<wxVisualAttributes > result;
35853 int val1 ;
35854 int ecode1 = 0 ;
35855 PyObject * obj0 = 0 ;
35856 char * kwnames[] = {
35857 (char *) "variant", NULL
35858 };
35859
35860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35861 if (obj0) {
35862 ecode1 = SWIG_AsVal_int(obj0, &val1);
35863 if (!SWIG_IsOK(ecode1)) {
35864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35865 }
35866 arg1 = static_cast< wxWindowVariant >(val1);
35867 }
35868 {
35869 if (!wxPyCheckForApp()) SWIG_fail;
35870 PyThreadState* __tstate = wxPyBeginAllowThreads();
35871 result = wxWindow::GetClassDefaultAttributes(arg1);
35872 wxPyEndAllowThreads(__tstate);
35873 if (PyErr_Occurred()) SWIG_fail;
35874 }
35875 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35876 return resultobj;
35877 fail:
35878 return NULL;
35879 }
35880
35881
35882 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35883 PyObject *resultobj = 0;
35884 wxWindow *arg1 = (wxWindow *) 0 ;
35885 wxColour *arg2 = 0 ;
35886 bool result;
35887 void *argp1 = 0 ;
35888 int res1 = 0 ;
35889 wxColour temp2 ;
35890 PyObject * obj0 = 0 ;
35891 PyObject * obj1 = 0 ;
35892 char * kwnames[] = {
35893 (char *) "self",(char *) "colour", NULL
35894 };
35895
35896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35898 if (!SWIG_IsOK(res1)) {
35899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35900 }
35901 arg1 = reinterpret_cast< wxWindow * >(argp1);
35902 {
35903 arg2 = &temp2;
35904 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35905 }
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35909 wxPyEndAllowThreads(__tstate);
35910 if (PyErr_Occurred()) SWIG_fail;
35911 }
35912 {
35913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35914 }
35915 return resultobj;
35916 fail:
35917 return NULL;
35918 }
35919
35920
35921 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35922 PyObject *resultobj = 0;
35923 wxWindow *arg1 = (wxWindow *) 0 ;
35924 wxColour *arg2 = 0 ;
35925 void *argp1 = 0 ;
35926 int res1 = 0 ;
35927 wxColour temp2 ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 char * kwnames[] = {
35931 (char *) "self",(char *) "colour", NULL
35932 };
35933
35934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 {
35941 arg2 = &temp2;
35942 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35943 }
35944 {
35945 PyThreadState* __tstate = wxPyBeginAllowThreads();
35946 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 resultobj = SWIG_Py_Void();
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35958 PyObject *resultobj = 0;
35959 wxWindow *arg1 = (wxWindow *) 0 ;
35960 wxColour *arg2 = 0 ;
35961 bool result;
35962 void *argp1 = 0 ;
35963 int res1 = 0 ;
35964 wxColour temp2 ;
35965 PyObject * obj0 = 0 ;
35966 PyObject * obj1 = 0 ;
35967 char * kwnames[] = {
35968 (char *) "self",(char *) "colour", NULL
35969 };
35970
35971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35973 if (!SWIG_IsOK(res1)) {
35974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35975 }
35976 arg1 = reinterpret_cast< wxWindow * >(argp1);
35977 {
35978 arg2 = &temp2;
35979 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35980 }
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 {
35988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35989 }
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 wxColour *arg2 = 0 ;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002 wxColour temp2 ;
36003 PyObject * obj0 = 0 ;
36004 PyObject * obj1 = 0 ;
36005 char * kwnames[] = {
36006 (char *) "self",(char *) "colour", NULL
36007 };
36008
36009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36011 if (!SWIG_IsOK(res1)) {
36012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36013 }
36014 arg1 = reinterpret_cast< wxWindow * >(argp1);
36015 {
36016 arg2 = &temp2;
36017 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36018 }
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 resultobj = SWIG_Py_Void();
36026 return resultobj;
36027 fail:
36028 return NULL;
36029 }
36030
36031
36032 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36033 PyObject *resultobj = 0;
36034 wxWindow *arg1 = (wxWindow *) 0 ;
36035 wxColour result;
36036 void *argp1 = 0 ;
36037 int res1 = 0 ;
36038 PyObject *swig_obj[1] ;
36039
36040 if (!args) SWIG_fail;
36041 swig_obj[0] = args;
36042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36043 if (!SWIG_IsOK(res1)) {
36044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36045 }
36046 arg1 = reinterpret_cast< wxWindow * >(argp1);
36047 {
36048 PyThreadState* __tstate = wxPyBeginAllowThreads();
36049 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36050 wxPyEndAllowThreads(__tstate);
36051 if (PyErr_Occurred()) SWIG_fail;
36052 }
36053 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36061 PyObject *resultobj = 0;
36062 wxWindow *arg1 = (wxWindow *) 0 ;
36063 wxColour result;
36064 void *argp1 = 0 ;
36065 int res1 = 0 ;
36066 PyObject *swig_obj[1] ;
36067
36068 if (!args) SWIG_fail;
36069 swig_obj[0] = args;
36070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36073 }
36074 arg1 = reinterpret_cast< wxWindow * >(argp1);
36075 {
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 result = ((wxWindow const *)arg1)->GetForegroundColour();
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36082 return resultobj;
36083 fail:
36084 return NULL;
36085 }
36086
36087
36088 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36089 PyObject *resultobj = 0;
36090 wxWindow *arg1 = (wxWindow *) 0 ;
36091 bool result;
36092 void *argp1 = 0 ;
36093 int res1 = 0 ;
36094 PyObject *swig_obj[1] ;
36095
36096 if (!args) SWIG_fail;
36097 swig_obj[0] = args;
36098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36099 if (!SWIG_IsOK(res1)) {
36100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36101 }
36102 arg1 = reinterpret_cast< wxWindow * >(argp1);
36103 {
36104 PyThreadState* __tstate = wxPyBeginAllowThreads();
36105 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36106 wxPyEndAllowThreads(__tstate);
36107 if (PyErr_Occurred()) SWIG_fail;
36108 }
36109 {
36110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36111 }
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36119 PyObject *resultobj = 0;
36120 wxWindow *arg1 = (wxWindow *) 0 ;
36121 bool result;
36122 void *argp1 = 0 ;
36123 int res1 = 0 ;
36124 PyObject *swig_obj[1] ;
36125
36126 if (!args) SWIG_fail;
36127 swig_obj[0] = args;
36128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36129 if (!SWIG_IsOK(res1)) {
36130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36131 }
36132 arg1 = reinterpret_cast< wxWindow * >(argp1);
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36136 wxPyEndAllowThreads(__tstate);
36137 if (PyErr_Occurred()) SWIG_fail;
36138 }
36139 {
36140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36141 }
36142 return resultobj;
36143 fail:
36144 return NULL;
36145 }
36146
36147
36148 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36149 PyObject *resultobj = 0;
36150 wxWindow *arg1 = (wxWindow *) 0 ;
36151 wxBackgroundStyle arg2 ;
36152 bool result;
36153 void *argp1 = 0 ;
36154 int res1 = 0 ;
36155 int val2 ;
36156 int ecode2 = 0 ;
36157 PyObject * obj0 = 0 ;
36158 PyObject * obj1 = 0 ;
36159 char * kwnames[] = {
36160 (char *) "self",(char *) "style", NULL
36161 };
36162
36163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36165 if (!SWIG_IsOK(res1)) {
36166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36167 }
36168 arg1 = reinterpret_cast< wxWindow * >(argp1);
36169 ecode2 = SWIG_AsVal_int(obj1, &val2);
36170 if (!SWIG_IsOK(ecode2)) {
36171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36172 }
36173 arg2 = static_cast< wxBackgroundStyle >(val2);
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36177 wxPyEndAllowThreads(__tstate);
36178 if (PyErr_Occurred()) SWIG_fail;
36179 }
36180 {
36181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36182 }
36183 return resultobj;
36184 fail:
36185 return NULL;
36186 }
36187
36188
36189 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36190 PyObject *resultobj = 0;
36191 wxWindow *arg1 = (wxWindow *) 0 ;
36192 wxBackgroundStyle result;
36193 void *argp1 = 0 ;
36194 int res1 = 0 ;
36195 PyObject *swig_obj[1] ;
36196
36197 if (!args) SWIG_fail;
36198 swig_obj[0] = args;
36199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36200 if (!SWIG_IsOK(res1)) {
36201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36202 }
36203 arg1 = reinterpret_cast< wxWindow * >(argp1);
36204 {
36205 PyThreadState* __tstate = wxPyBeginAllowThreads();
36206 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 resultobj = SWIG_From_int(static_cast< int >(result));
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36218 PyObject *resultobj = 0;
36219 wxWindow *arg1 = (wxWindow *) 0 ;
36220 bool result;
36221 void *argp1 = 0 ;
36222 int res1 = 0 ;
36223 PyObject *swig_obj[1] ;
36224
36225 if (!args) SWIG_fail;
36226 swig_obj[0] = args;
36227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36228 if (!SWIG_IsOK(res1)) {
36229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36230 }
36231 arg1 = reinterpret_cast< wxWindow * >(argp1);
36232 {
36233 PyThreadState* __tstate = wxPyBeginAllowThreads();
36234 result = (bool)(arg1)->HasTransparentBackground();
36235 wxPyEndAllowThreads(__tstate);
36236 if (PyErr_Occurred()) SWIG_fail;
36237 }
36238 {
36239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36240 }
36241 return resultobj;
36242 fail:
36243 return NULL;
36244 }
36245
36246
36247 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36248 PyObject *resultobj = 0;
36249 wxWindow *arg1 = (wxWindow *) 0 ;
36250 wxCursor *arg2 = 0 ;
36251 bool result;
36252 void *argp1 = 0 ;
36253 int res1 = 0 ;
36254 void *argp2 = 0 ;
36255 int res2 = 0 ;
36256 PyObject * obj0 = 0 ;
36257 PyObject * obj1 = 0 ;
36258 char * kwnames[] = {
36259 (char *) "self",(char *) "cursor", NULL
36260 };
36261
36262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36264 if (!SWIG_IsOK(res1)) {
36265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36266 }
36267 arg1 = reinterpret_cast< wxWindow * >(argp1);
36268 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36269 if (!SWIG_IsOK(res2)) {
36270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36271 }
36272 if (!argp2) {
36273 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36274 }
36275 arg2 = reinterpret_cast< wxCursor * >(argp2);
36276 {
36277 PyThreadState* __tstate = wxPyBeginAllowThreads();
36278 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36279 wxPyEndAllowThreads(__tstate);
36280 if (PyErr_Occurred()) SWIG_fail;
36281 }
36282 {
36283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36284 }
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxWindow *arg1 = (wxWindow *) 0 ;
36294 wxCursor result;
36295 void *argp1 = 0 ;
36296 int res1 = 0 ;
36297 PyObject *swig_obj[1] ;
36298
36299 if (!args) SWIG_fail;
36300 swig_obj[0] = args;
36301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36304 }
36305 arg1 = reinterpret_cast< wxWindow * >(argp1);
36306 {
36307 PyThreadState* __tstate = wxPyBeginAllowThreads();
36308 result = (arg1)->GetCursor();
36309 wxPyEndAllowThreads(__tstate);
36310 if (PyErr_Occurred()) SWIG_fail;
36311 }
36312 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36313 return resultobj;
36314 fail:
36315 return NULL;
36316 }
36317
36318
36319 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36320 PyObject *resultobj = 0;
36321 wxWindow *arg1 = (wxWindow *) 0 ;
36322 wxFont *arg2 = 0 ;
36323 bool result;
36324 void *argp1 = 0 ;
36325 int res1 = 0 ;
36326 void *argp2 = 0 ;
36327 int res2 = 0 ;
36328 PyObject * obj0 = 0 ;
36329 PyObject * obj1 = 0 ;
36330 char * kwnames[] = {
36331 (char *) "self",(char *) "font", NULL
36332 };
36333
36334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36336 if (!SWIG_IsOK(res1)) {
36337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36338 }
36339 arg1 = reinterpret_cast< wxWindow * >(argp1);
36340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36341 if (!SWIG_IsOK(res2)) {
36342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36343 }
36344 if (!argp2) {
36345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36346 }
36347 arg2 = reinterpret_cast< wxFont * >(argp2);
36348 {
36349 PyThreadState* __tstate = wxPyBeginAllowThreads();
36350 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36351 wxPyEndAllowThreads(__tstate);
36352 if (PyErr_Occurred()) SWIG_fail;
36353 }
36354 {
36355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36356 }
36357 return resultobj;
36358 fail:
36359 return NULL;
36360 }
36361
36362
36363 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36364 PyObject *resultobj = 0;
36365 wxWindow *arg1 = (wxWindow *) 0 ;
36366 wxFont *arg2 = 0 ;
36367 void *argp1 = 0 ;
36368 int res1 = 0 ;
36369 void *argp2 = 0 ;
36370 int res2 = 0 ;
36371 PyObject * obj0 = 0 ;
36372 PyObject * obj1 = 0 ;
36373 char * kwnames[] = {
36374 (char *) "self",(char *) "font", NULL
36375 };
36376
36377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36379 if (!SWIG_IsOK(res1)) {
36380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36381 }
36382 arg1 = reinterpret_cast< wxWindow * >(argp1);
36383 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36384 if (!SWIG_IsOK(res2)) {
36385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36386 }
36387 if (!argp2) {
36388 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36389 }
36390 arg2 = reinterpret_cast< wxFont * >(argp2);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 (arg1)->SetOwnFont((wxFont const &)*arg2);
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 resultobj = SWIG_Py_Void();
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 wxFont result;
36408 void *argp1 = 0 ;
36409 int res1 = 0 ;
36410 PyObject *swig_obj[1] ;
36411
36412 if (!args) SWIG_fail;
36413 swig_obj[0] = args;
36414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36415 if (!SWIG_IsOK(res1)) {
36416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36417 }
36418 arg1 = reinterpret_cast< wxWindow * >(argp1);
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (arg1)->GetFont();
36422 wxPyEndAllowThreads(__tstate);
36423 if (PyErr_Occurred()) SWIG_fail;
36424 }
36425 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36426 return resultobj;
36427 fail:
36428 return NULL;
36429 }
36430
36431
36432 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36433 PyObject *resultobj = 0;
36434 wxWindow *arg1 = (wxWindow *) 0 ;
36435 wxCaret *arg2 = (wxCaret *) 0 ;
36436 void *argp1 = 0 ;
36437 int res1 = 0 ;
36438 int res2 = 0 ;
36439 PyObject * obj0 = 0 ;
36440 PyObject * obj1 = 0 ;
36441 char * kwnames[] = {
36442 (char *) "self",(char *) "caret", NULL
36443 };
36444
36445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36452 if (!SWIG_IsOK(res2)) {
36453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36454 }
36455 {
36456 PyThreadState* __tstate = wxPyBeginAllowThreads();
36457 (arg1)->SetCaret(arg2);
36458 wxPyEndAllowThreads(__tstate);
36459 if (PyErr_Occurred()) SWIG_fail;
36460 }
36461 resultobj = SWIG_Py_Void();
36462 return resultobj;
36463 fail:
36464 return NULL;
36465 }
36466
36467
36468 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36469 PyObject *resultobj = 0;
36470 wxWindow *arg1 = (wxWindow *) 0 ;
36471 wxCaret *result = 0 ;
36472 void *argp1 = 0 ;
36473 int res1 = 0 ;
36474 PyObject *swig_obj[1] ;
36475
36476 if (!args) SWIG_fail;
36477 swig_obj[0] = args;
36478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36479 if (!SWIG_IsOK(res1)) {
36480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36481 }
36482 arg1 = reinterpret_cast< wxWindow * >(argp1);
36483 {
36484 PyThreadState* __tstate = wxPyBeginAllowThreads();
36485 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36486 wxPyEndAllowThreads(__tstate);
36487 if (PyErr_Occurred()) SWIG_fail;
36488 }
36489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36490 return resultobj;
36491 fail:
36492 return NULL;
36493 }
36494
36495
36496 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36497 PyObject *resultobj = 0;
36498 wxWindow *arg1 = (wxWindow *) 0 ;
36499 int result;
36500 void *argp1 = 0 ;
36501 int res1 = 0 ;
36502 PyObject *swig_obj[1] ;
36503
36504 if (!args) SWIG_fail;
36505 swig_obj[0] = args;
36506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36507 if (!SWIG_IsOK(res1)) {
36508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36509 }
36510 arg1 = reinterpret_cast< wxWindow * >(argp1);
36511 {
36512 PyThreadState* __tstate = wxPyBeginAllowThreads();
36513 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36514 wxPyEndAllowThreads(__tstate);
36515 if (PyErr_Occurred()) SWIG_fail;
36516 }
36517 resultobj = SWIG_From_int(static_cast< int >(result));
36518 return resultobj;
36519 fail:
36520 return NULL;
36521 }
36522
36523
36524 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36525 PyObject *resultobj = 0;
36526 wxWindow *arg1 = (wxWindow *) 0 ;
36527 int result;
36528 void *argp1 = 0 ;
36529 int res1 = 0 ;
36530 PyObject *swig_obj[1] ;
36531
36532 if (!args) SWIG_fail;
36533 swig_obj[0] = args;
36534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 {
36540 PyThreadState* __tstate = wxPyBeginAllowThreads();
36541 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36542 wxPyEndAllowThreads(__tstate);
36543 if (PyErr_Occurred()) SWIG_fail;
36544 }
36545 resultobj = SWIG_From_int(static_cast< int >(result));
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj = 0;
36554 wxWindow *arg1 = (wxWindow *) 0 ;
36555 wxString *arg2 = 0 ;
36556 int *arg3 = (int *) 0 ;
36557 int *arg4 = (int *) 0 ;
36558 void *argp1 = 0 ;
36559 int res1 = 0 ;
36560 bool temp2 = false ;
36561 int temp3 ;
36562 int res3 = SWIG_TMPOBJ ;
36563 int temp4 ;
36564 int res4 = SWIG_TMPOBJ ;
36565 PyObject * obj0 = 0 ;
36566 PyObject * obj1 = 0 ;
36567 char * kwnames[] = {
36568 (char *) "self",(char *) "string", NULL
36569 };
36570
36571 arg3 = &temp3;
36572 arg4 = &temp4;
36573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 {
36580 arg2 = wxString_in_helper(obj1);
36581 if (arg2 == NULL) SWIG_fail;
36582 temp2 = true;
36583 }
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 resultobj = SWIG_Py_Void();
36591 if (SWIG_IsTmpObj(res3)) {
36592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36593 } else {
36594 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36596 }
36597 if (SWIG_IsTmpObj(res4)) {
36598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36599 } else {
36600 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36602 }
36603 {
36604 if (temp2)
36605 delete arg2;
36606 }
36607 return resultobj;
36608 fail:
36609 {
36610 if (temp2)
36611 delete arg2;
36612 }
36613 return NULL;
36614 }
36615
36616
36617 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36618 PyObject *resultobj = 0;
36619 wxWindow *arg1 = (wxWindow *) 0 ;
36620 wxString *arg2 = 0 ;
36621 int *arg3 = (int *) 0 ;
36622 int *arg4 = (int *) 0 ;
36623 int *arg5 = (int *) 0 ;
36624 int *arg6 = (int *) 0 ;
36625 wxFont *arg7 = (wxFont *) NULL ;
36626 void *argp1 = 0 ;
36627 int res1 = 0 ;
36628 bool temp2 = false ;
36629 int temp3 ;
36630 int res3 = SWIG_TMPOBJ ;
36631 int temp4 ;
36632 int res4 = SWIG_TMPOBJ ;
36633 int temp5 ;
36634 int res5 = SWIG_TMPOBJ ;
36635 int temp6 ;
36636 int res6 = SWIG_TMPOBJ ;
36637 void *argp7 = 0 ;
36638 int res7 = 0 ;
36639 PyObject * obj0 = 0 ;
36640 PyObject * obj1 = 0 ;
36641 PyObject * obj2 = 0 ;
36642 char * kwnames[] = {
36643 (char *) "self",(char *) "string",(char *) "font", NULL
36644 };
36645
36646 arg3 = &temp3;
36647 arg4 = &temp4;
36648 arg5 = &temp5;
36649 arg6 = &temp6;
36650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36652 if (!SWIG_IsOK(res1)) {
36653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36654 }
36655 arg1 = reinterpret_cast< wxWindow * >(argp1);
36656 {
36657 arg2 = wxString_in_helper(obj1);
36658 if (arg2 == NULL) SWIG_fail;
36659 temp2 = true;
36660 }
36661 if (obj2) {
36662 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36663 if (!SWIG_IsOK(res7)) {
36664 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36665 }
36666 arg7 = reinterpret_cast< wxFont * >(argp7);
36667 }
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 resultobj = SWIG_Py_Void();
36675 if (SWIG_IsTmpObj(res3)) {
36676 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36677 } else {
36678 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36679 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36680 }
36681 if (SWIG_IsTmpObj(res4)) {
36682 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36683 } else {
36684 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36685 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36686 }
36687 if (SWIG_IsTmpObj(res5)) {
36688 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36689 } else {
36690 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36691 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36692 }
36693 if (SWIG_IsTmpObj(res6)) {
36694 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36695 } else {
36696 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36698 }
36699 {
36700 if (temp2)
36701 delete arg2;
36702 }
36703 return resultobj;
36704 fail:
36705 {
36706 if (temp2)
36707 delete arg2;
36708 }
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36714 PyObject *resultobj = 0;
36715 wxWindow *arg1 = (wxWindow *) 0 ;
36716 int *arg2 = (int *) 0 ;
36717 int *arg3 = (int *) 0 ;
36718 void *argp1 = 0 ;
36719 int res1 = 0 ;
36720 int temp2 ;
36721 int res2 = 0 ;
36722 int temp3 ;
36723 int res3 = 0 ;
36724 PyObject * obj0 = 0 ;
36725 PyObject * obj1 = 0 ;
36726 PyObject * obj2 = 0 ;
36727 char * kwnames[] = {
36728 (char *) "self",(char *) "x",(char *) "y", NULL
36729 };
36730
36731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36733 if (!SWIG_IsOK(res1)) {
36734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36735 }
36736 arg1 = reinterpret_cast< wxWindow * >(argp1);
36737 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36738 int val;
36739 int ecode = SWIG_AsVal_int(obj1, &val);
36740 if (!SWIG_IsOK(ecode)) {
36741 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36742 }
36743 temp2 = static_cast< int >(val);
36744 arg2 = &temp2;
36745 res2 = SWIG_AddTmpMask(ecode);
36746 }
36747 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36748 int val;
36749 int ecode = SWIG_AsVal_int(obj2, &val);
36750 if (!SWIG_IsOK(ecode)) {
36751 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36752 }
36753 temp3 = static_cast< int >(val);
36754 arg3 = &temp3;
36755 res3 = SWIG_AddTmpMask(ecode);
36756 }
36757 {
36758 PyThreadState* __tstate = wxPyBeginAllowThreads();
36759 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36760 wxPyEndAllowThreads(__tstate);
36761 if (PyErr_Occurred()) SWIG_fail;
36762 }
36763 resultobj = SWIG_Py_Void();
36764 if (SWIG_IsTmpObj(res2)) {
36765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36766 } else {
36767 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36769 }
36770 if (SWIG_IsTmpObj(res3)) {
36771 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36772 } else {
36773 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36774 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36775 }
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36783 PyObject *resultobj = 0;
36784 wxWindow *arg1 = (wxWindow *) 0 ;
36785 int *arg2 = (int *) 0 ;
36786 int *arg3 = (int *) 0 ;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 int temp2 ;
36790 int res2 = 0 ;
36791 int temp3 ;
36792 int res3 = 0 ;
36793 PyObject * obj0 = 0 ;
36794 PyObject * obj1 = 0 ;
36795 PyObject * obj2 = 0 ;
36796 char * kwnames[] = {
36797 (char *) "self",(char *) "x",(char *) "y", NULL
36798 };
36799
36800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36802 if (!SWIG_IsOK(res1)) {
36803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36804 }
36805 arg1 = reinterpret_cast< wxWindow * >(argp1);
36806 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36807 int val;
36808 int ecode = SWIG_AsVal_int(obj1, &val);
36809 if (!SWIG_IsOK(ecode)) {
36810 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36811 }
36812 temp2 = static_cast< int >(val);
36813 arg2 = &temp2;
36814 res2 = SWIG_AddTmpMask(ecode);
36815 }
36816 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36817 int val;
36818 int ecode = SWIG_AsVal_int(obj2, &val);
36819 if (!SWIG_IsOK(ecode)) {
36820 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36821 }
36822 temp3 = static_cast< int >(val);
36823 arg3 = &temp3;
36824 res3 = SWIG_AddTmpMask(ecode);
36825 }
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 resultobj = SWIG_Py_Void();
36833 if (SWIG_IsTmpObj(res2)) {
36834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36835 } else {
36836 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36838 }
36839 if (SWIG_IsTmpObj(res3)) {
36840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36841 } else {
36842 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36844 }
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36852 PyObject *resultobj = 0;
36853 wxWindow *arg1 = (wxWindow *) 0 ;
36854 wxPoint *arg2 = 0 ;
36855 wxPoint result;
36856 void *argp1 = 0 ;
36857 int res1 = 0 ;
36858 wxPoint temp2 ;
36859 PyObject * obj0 = 0 ;
36860 PyObject * obj1 = 0 ;
36861 char * kwnames[] = {
36862 (char *) "self",(char *) "pt", NULL
36863 };
36864
36865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 {
36872 arg2 = &temp2;
36873 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36874 }
36875 {
36876 PyThreadState* __tstate = wxPyBeginAllowThreads();
36877 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36878 wxPyEndAllowThreads(__tstate);
36879 if (PyErr_Occurred()) SWIG_fail;
36880 }
36881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36882 return resultobj;
36883 fail:
36884 return NULL;
36885 }
36886
36887
36888 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36889 PyObject *resultobj = 0;
36890 wxWindow *arg1 = (wxWindow *) 0 ;
36891 wxPoint *arg2 = 0 ;
36892 wxPoint result;
36893 void *argp1 = 0 ;
36894 int res1 = 0 ;
36895 wxPoint temp2 ;
36896 PyObject * obj0 = 0 ;
36897 PyObject * obj1 = 0 ;
36898 char * kwnames[] = {
36899 (char *) "self",(char *) "pt", NULL
36900 };
36901
36902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36904 if (!SWIG_IsOK(res1)) {
36905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36906 }
36907 arg1 = reinterpret_cast< wxWindow * >(argp1);
36908 {
36909 arg2 = &temp2;
36910 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36911 }
36912 {
36913 PyThreadState* __tstate = wxPyBeginAllowThreads();
36914 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36915 wxPyEndAllowThreads(__tstate);
36916 if (PyErr_Occurred()) SWIG_fail;
36917 }
36918 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36919 return resultobj;
36920 fail:
36921 return NULL;
36922 }
36923
36924
36925 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36926 PyObject *resultobj = 0;
36927 wxWindow *arg1 = (wxWindow *) 0 ;
36928 int arg2 ;
36929 int arg3 ;
36930 wxHitTest result;
36931 void *argp1 = 0 ;
36932 int res1 = 0 ;
36933 int val2 ;
36934 int ecode2 = 0 ;
36935 int val3 ;
36936 int ecode3 = 0 ;
36937 PyObject * obj0 = 0 ;
36938 PyObject * obj1 = 0 ;
36939 PyObject * obj2 = 0 ;
36940 char * kwnames[] = {
36941 (char *) "self",(char *) "x",(char *) "y", NULL
36942 };
36943
36944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36946 if (!SWIG_IsOK(res1)) {
36947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36948 }
36949 arg1 = reinterpret_cast< wxWindow * >(argp1);
36950 ecode2 = SWIG_AsVal_int(obj1, &val2);
36951 if (!SWIG_IsOK(ecode2)) {
36952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36953 }
36954 arg2 = static_cast< int >(val2);
36955 ecode3 = SWIG_AsVal_int(obj2, &val3);
36956 if (!SWIG_IsOK(ecode3)) {
36957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36958 }
36959 arg3 = static_cast< int >(val3);
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36963 wxPyEndAllowThreads(__tstate);
36964 if (PyErr_Occurred()) SWIG_fail;
36965 }
36966 resultobj = SWIG_From_int(static_cast< int >(result));
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 wxPoint *arg2 = 0 ;
36977 wxHitTest result;
36978 void *argp1 = 0 ;
36979 int res1 = 0 ;
36980 wxPoint temp2 ;
36981 PyObject * obj0 = 0 ;
36982 PyObject * obj1 = 0 ;
36983 char * kwnames[] = {
36984 (char *) "self",(char *) "pt", NULL
36985 };
36986
36987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36989 if (!SWIG_IsOK(res1)) {
36990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36991 }
36992 arg1 = reinterpret_cast< wxWindow * >(argp1);
36993 {
36994 arg2 = &temp2;
36995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36996 }
36997 {
36998 PyThreadState* __tstate = wxPyBeginAllowThreads();
36999 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 resultobj = SWIG_From_int(static_cast< int >(result));
37004 return resultobj;
37005 fail:
37006 return NULL;
37007 }
37008
37009
37010 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37011 PyObject *resultobj = 0;
37012 wxWindow *arg1 = (wxWindow *) 0 ;
37013 long arg2 ;
37014 wxBorder result;
37015 void *argp1 = 0 ;
37016 int res1 = 0 ;
37017 long val2 ;
37018 int ecode2 = 0 ;
37019
37020 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37022 if (!SWIG_IsOK(res1)) {
37023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37024 }
37025 arg1 = reinterpret_cast< wxWindow * >(argp1);
37026 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37027 if (!SWIG_IsOK(ecode2)) {
37028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37029 }
37030 arg2 = static_cast< long >(val2);
37031 {
37032 PyThreadState* __tstate = wxPyBeginAllowThreads();
37033 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37034 wxPyEndAllowThreads(__tstate);
37035 if (PyErr_Occurred()) SWIG_fail;
37036 }
37037 resultobj = SWIG_From_int(static_cast< int >(result));
37038 return resultobj;
37039 fail:
37040 return NULL;
37041 }
37042
37043
37044 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37045 PyObject *resultobj = 0;
37046 wxWindow *arg1 = (wxWindow *) 0 ;
37047 wxBorder result;
37048 void *argp1 = 0 ;
37049 int res1 = 0 ;
37050
37051 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37053 if (!SWIG_IsOK(res1)) {
37054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37055 }
37056 arg1 = reinterpret_cast< wxWindow * >(argp1);
37057 {
37058 PyThreadState* __tstate = wxPyBeginAllowThreads();
37059 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37060 wxPyEndAllowThreads(__tstate);
37061 if (PyErr_Occurred()) SWIG_fail;
37062 }
37063 resultobj = SWIG_From_int(static_cast< int >(result));
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37071 int argc;
37072 PyObject *argv[3];
37073
37074 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37075 --argc;
37076 if (argc == 1) {
37077 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37078 }
37079 if (argc == 2) {
37080 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37081 }
37082
37083 fail:
37084 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37085 return NULL;
37086 }
37087
37088
37089 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37090 PyObject *resultobj = 0;
37091 wxWindow *arg1 = (wxWindow *) 0 ;
37092 long arg2 = (long) wxUPDATE_UI_NONE ;
37093 void *argp1 = 0 ;
37094 int res1 = 0 ;
37095 long val2 ;
37096 int ecode2 = 0 ;
37097 PyObject * obj0 = 0 ;
37098 PyObject * obj1 = 0 ;
37099 char * kwnames[] = {
37100 (char *) "self",(char *) "flags", NULL
37101 };
37102
37103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37105 if (!SWIG_IsOK(res1)) {
37106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37107 }
37108 arg1 = reinterpret_cast< wxWindow * >(argp1);
37109 if (obj1) {
37110 ecode2 = SWIG_AsVal_long(obj1, &val2);
37111 if (!SWIG_IsOK(ecode2)) {
37112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37113 }
37114 arg2 = static_cast< long >(val2);
37115 }
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 (arg1)->UpdateWindowUI(arg2);
37119 wxPyEndAllowThreads(__tstate);
37120 if (PyErr_Occurred()) SWIG_fail;
37121 }
37122 resultobj = SWIG_Py_Void();
37123 return resultobj;
37124 fail:
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37130 PyObject *resultobj = 0;
37131 wxWindow *arg1 = (wxWindow *) 0 ;
37132 wxMenu *arg2 = (wxMenu *) 0 ;
37133 int arg3 = (int) -1 ;
37134 int arg4 = (int) -1 ;
37135 bool result;
37136 void *argp1 = 0 ;
37137 int res1 = 0 ;
37138 void *argp2 = 0 ;
37139 int res2 = 0 ;
37140 int val3 ;
37141 int ecode3 = 0 ;
37142 int val4 ;
37143 int ecode4 = 0 ;
37144 PyObject * obj0 = 0 ;
37145 PyObject * obj1 = 0 ;
37146 PyObject * obj2 = 0 ;
37147 PyObject * obj3 = 0 ;
37148 char * kwnames[] = {
37149 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37150 };
37151
37152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37156 }
37157 arg1 = reinterpret_cast< wxWindow * >(argp1);
37158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37159 if (!SWIG_IsOK(res2)) {
37160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37161 }
37162 arg2 = reinterpret_cast< wxMenu * >(argp2);
37163 if (obj2) {
37164 ecode3 = SWIG_AsVal_int(obj2, &val3);
37165 if (!SWIG_IsOK(ecode3)) {
37166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37167 }
37168 arg3 = static_cast< int >(val3);
37169 }
37170 if (obj3) {
37171 ecode4 = SWIG_AsVal_int(obj3, &val4);
37172 if (!SWIG_IsOK(ecode4)) {
37173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37174 }
37175 arg4 = static_cast< int >(val4);
37176 }
37177 {
37178 PyThreadState* __tstate = wxPyBeginAllowThreads();
37179 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37180 wxPyEndAllowThreads(__tstate);
37181 if (PyErr_Occurred()) SWIG_fail;
37182 }
37183 {
37184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37185 }
37186 return resultobj;
37187 fail:
37188 return NULL;
37189 }
37190
37191
37192 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37193 PyObject *resultobj = 0;
37194 wxWindow *arg1 = (wxWindow *) 0 ;
37195 wxMenu *arg2 = (wxMenu *) 0 ;
37196 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37197 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37198 bool result;
37199 void *argp1 = 0 ;
37200 int res1 = 0 ;
37201 void *argp2 = 0 ;
37202 int res2 = 0 ;
37203 wxPoint temp3 ;
37204 PyObject * obj0 = 0 ;
37205 PyObject * obj1 = 0 ;
37206 PyObject * obj2 = 0 ;
37207 char * kwnames[] = {
37208 (char *) "self",(char *) "menu",(char *) "pos", NULL
37209 };
37210
37211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37213 if (!SWIG_IsOK(res1)) {
37214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37215 }
37216 arg1 = reinterpret_cast< wxWindow * >(argp1);
37217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37218 if (!SWIG_IsOK(res2)) {
37219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37220 }
37221 arg2 = reinterpret_cast< wxMenu * >(argp2);
37222 if (obj2) {
37223 {
37224 arg3 = &temp3;
37225 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37226 }
37227 }
37228 {
37229 PyThreadState* __tstate = wxPyBeginAllowThreads();
37230 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37231 wxPyEndAllowThreads(__tstate);
37232 if (PyErr_Occurred()) SWIG_fail;
37233 }
37234 {
37235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37236 }
37237 return resultobj;
37238 fail:
37239 return NULL;
37240 }
37241
37242
37243 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37244 PyObject *resultobj = 0;
37245 wxWindow *arg1 = (wxWindow *) 0 ;
37246 bool result;
37247 void *argp1 = 0 ;
37248 int res1 = 0 ;
37249 PyObject *swig_obj[1] ;
37250
37251 if (!args) SWIG_fail;
37252 swig_obj[0] = args;
37253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37254 if (!SWIG_IsOK(res1)) {
37255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37256 }
37257 arg1 = reinterpret_cast< wxWindow * >(argp1);
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 {
37265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37266 }
37267 return resultobj;
37268 fail:
37269 return NULL;
37270 }
37271
37272
37273 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37274 PyObject *resultobj = 0;
37275 wxWindow *arg1 = (wxWindow *) 0 ;
37276 long result;
37277 void *argp1 = 0 ;
37278 int res1 = 0 ;
37279 PyObject *swig_obj[1] ;
37280
37281 if (!args) SWIG_fail;
37282 swig_obj[0] = args;
37283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37284 if (!SWIG_IsOK(res1)) {
37285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37286 }
37287 arg1 = reinterpret_cast< wxWindow * >(argp1);
37288 {
37289 PyThreadState* __tstate = wxPyBeginAllowThreads();
37290 result = (long)wxWindow_GetHandle(arg1);
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 resultobj = SWIG_From_long(static_cast< long >(result));
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 long arg2 ;
37305 void *argp1 = 0 ;
37306 int res1 = 0 ;
37307 long val2 ;
37308 int ecode2 = 0 ;
37309 PyObject * obj0 = 0 ;
37310 PyObject * obj1 = 0 ;
37311 char * kwnames[] = {
37312 (char *) "self",(char *) "handle", NULL
37313 };
37314
37315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37317 if (!SWIG_IsOK(res1)) {
37318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37319 }
37320 arg1 = reinterpret_cast< wxWindow * >(argp1);
37321 ecode2 = SWIG_AsVal_long(obj1, &val2);
37322 if (!SWIG_IsOK(ecode2)) {
37323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37324 }
37325 arg2 = static_cast< long >(val2);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 wxWindow_AssociateHandle(arg1,arg2);
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 resultobj = SWIG_Py_Void();
37333 return resultobj;
37334 fail:
37335 return NULL;
37336 }
37337
37338
37339 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37340 PyObject *resultobj = 0;
37341 wxWindow *arg1 = (wxWindow *) 0 ;
37342 void *argp1 = 0 ;
37343 int res1 = 0 ;
37344 PyObject *swig_obj[1] ;
37345
37346 if (!args) SWIG_fail;
37347 swig_obj[0] = args;
37348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37349 if (!SWIG_IsOK(res1)) {
37350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37351 }
37352 arg1 = reinterpret_cast< wxWindow * >(argp1);
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 (arg1)->DissociateHandle();
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 resultobj = SWIG_Py_Void();
37360 return resultobj;
37361 fail:
37362 return NULL;
37363 }
37364
37365
37366 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37367 PyObject *resultobj = 0;
37368 wxWindow *arg1 = (wxWindow *) 0 ;
37369 int arg2 ;
37370 bool result;
37371 void *argp1 = 0 ;
37372 int res1 = 0 ;
37373 int val2 ;
37374 int ecode2 = 0 ;
37375 PyObject * obj0 = 0 ;
37376 PyObject * obj1 = 0 ;
37377 char * kwnames[] = {
37378 (char *) "self",(char *) "orient", NULL
37379 };
37380
37381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37383 if (!SWIG_IsOK(res1)) {
37384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37385 }
37386 arg1 = reinterpret_cast< wxWindow * >(argp1);
37387 ecode2 = SWIG_AsVal_int(obj1, &val2);
37388 if (!SWIG_IsOK(ecode2)) {
37389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37390 }
37391 arg2 = static_cast< int >(val2);
37392 {
37393 PyThreadState* __tstate = wxPyBeginAllowThreads();
37394 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37395 wxPyEndAllowThreads(__tstate);
37396 if (PyErr_Occurred()) SWIG_fail;
37397 }
37398 {
37399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37400 }
37401 return resultobj;
37402 fail:
37403 return NULL;
37404 }
37405
37406
37407 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37408 PyObject *resultobj = 0;
37409 wxWindow *arg1 = (wxWindow *) 0 ;
37410 int arg2 ;
37411 int arg3 ;
37412 int arg4 ;
37413 int arg5 ;
37414 bool arg6 = (bool) true ;
37415 void *argp1 = 0 ;
37416 int res1 = 0 ;
37417 int val2 ;
37418 int ecode2 = 0 ;
37419 int val3 ;
37420 int ecode3 = 0 ;
37421 int val4 ;
37422 int ecode4 = 0 ;
37423 int val5 ;
37424 int ecode5 = 0 ;
37425 bool val6 ;
37426 int ecode6 = 0 ;
37427 PyObject * obj0 = 0 ;
37428 PyObject * obj1 = 0 ;
37429 PyObject * obj2 = 0 ;
37430 PyObject * obj3 = 0 ;
37431 PyObject * obj4 = 0 ;
37432 PyObject * obj5 = 0 ;
37433 char * kwnames[] = {
37434 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37435 };
37436
37437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37439 if (!SWIG_IsOK(res1)) {
37440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37441 }
37442 arg1 = reinterpret_cast< wxWindow * >(argp1);
37443 ecode2 = SWIG_AsVal_int(obj1, &val2);
37444 if (!SWIG_IsOK(ecode2)) {
37445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37446 }
37447 arg2 = static_cast< int >(val2);
37448 ecode3 = SWIG_AsVal_int(obj2, &val3);
37449 if (!SWIG_IsOK(ecode3)) {
37450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37451 }
37452 arg3 = static_cast< int >(val3);
37453 ecode4 = SWIG_AsVal_int(obj3, &val4);
37454 if (!SWIG_IsOK(ecode4)) {
37455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37456 }
37457 arg4 = static_cast< int >(val4);
37458 ecode5 = SWIG_AsVal_int(obj4, &val5);
37459 if (!SWIG_IsOK(ecode5)) {
37460 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37461 }
37462 arg5 = static_cast< int >(val5);
37463 if (obj5) {
37464 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37465 if (!SWIG_IsOK(ecode6)) {
37466 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37467 }
37468 arg6 = static_cast< bool >(val6);
37469 }
37470 {
37471 PyThreadState* __tstate = wxPyBeginAllowThreads();
37472 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37473 wxPyEndAllowThreads(__tstate);
37474 if (PyErr_Occurred()) SWIG_fail;
37475 }
37476 resultobj = SWIG_Py_Void();
37477 return resultobj;
37478 fail:
37479 return NULL;
37480 }
37481
37482
37483 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37484 PyObject *resultobj = 0;
37485 wxWindow *arg1 = (wxWindow *) 0 ;
37486 int arg2 ;
37487 int arg3 ;
37488 bool arg4 = (bool) true ;
37489 void *argp1 = 0 ;
37490 int res1 = 0 ;
37491 int val2 ;
37492 int ecode2 = 0 ;
37493 int val3 ;
37494 int ecode3 = 0 ;
37495 bool val4 ;
37496 int ecode4 = 0 ;
37497 PyObject * obj0 = 0 ;
37498 PyObject * obj1 = 0 ;
37499 PyObject * obj2 = 0 ;
37500 PyObject * obj3 = 0 ;
37501 char * kwnames[] = {
37502 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37503 };
37504
37505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37507 if (!SWIG_IsOK(res1)) {
37508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37509 }
37510 arg1 = reinterpret_cast< wxWindow * >(argp1);
37511 ecode2 = SWIG_AsVal_int(obj1, &val2);
37512 if (!SWIG_IsOK(ecode2)) {
37513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37514 }
37515 arg2 = static_cast< int >(val2);
37516 ecode3 = SWIG_AsVal_int(obj2, &val3);
37517 if (!SWIG_IsOK(ecode3)) {
37518 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37519 }
37520 arg3 = static_cast< int >(val3);
37521 if (obj3) {
37522 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37523 if (!SWIG_IsOK(ecode4)) {
37524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37525 }
37526 arg4 = static_cast< bool >(val4);
37527 }
37528 {
37529 PyThreadState* __tstate = wxPyBeginAllowThreads();
37530 (arg1)->SetScrollPos(arg2,arg3,arg4);
37531 wxPyEndAllowThreads(__tstate);
37532 if (PyErr_Occurred()) SWIG_fail;
37533 }
37534 resultobj = SWIG_Py_Void();
37535 return resultobj;
37536 fail:
37537 return NULL;
37538 }
37539
37540
37541 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37542 PyObject *resultobj = 0;
37543 wxWindow *arg1 = (wxWindow *) 0 ;
37544 int arg2 ;
37545 int result;
37546 void *argp1 = 0 ;
37547 int res1 = 0 ;
37548 int val2 ;
37549 int ecode2 = 0 ;
37550 PyObject * obj0 = 0 ;
37551 PyObject * obj1 = 0 ;
37552 char * kwnames[] = {
37553 (char *) "self",(char *) "orientation", NULL
37554 };
37555
37556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37558 if (!SWIG_IsOK(res1)) {
37559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37560 }
37561 arg1 = reinterpret_cast< wxWindow * >(argp1);
37562 ecode2 = SWIG_AsVal_int(obj1, &val2);
37563 if (!SWIG_IsOK(ecode2)) {
37564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37565 }
37566 arg2 = static_cast< int >(val2);
37567 {
37568 PyThreadState* __tstate = wxPyBeginAllowThreads();
37569 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37570 wxPyEndAllowThreads(__tstate);
37571 if (PyErr_Occurred()) SWIG_fail;
37572 }
37573 resultobj = SWIG_From_int(static_cast< int >(result));
37574 return resultobj;
37575 fail:
37576 return NULL;
37577 }
37578
37579
37580 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37581 PyObject *resultobj = 0;
37582 wxWindow *arg1 = (wxWindow *) 0 ;
37583 int arg2 ;
37584 int result;
37585 void *argp1 = 0 ;
37586 int res1 = 0 ;
37587 int val2 ;
37588 int ecode2 = 0 ;
37589 PyObject * obj0 = 0 ;
37590 PyObject * obj1 = 0 ;
37591 char * kwnames[] = {
37592 (char *) "self",(char *) "orientation", NULL
37593 };
37594
37595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37597 if (!SWIG_IsOK(res1)) {
37598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37599 }
37600 arg1 = reinterpret_cast< wxWindow * >(argp1);
37601 ecode2 = SWIG_AsVal_int(obj1, &val2);
37602 if (!SWIG_IsOK(ecode2)) {
37603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37604 }
37605 arg2 = static_cast< int >(val2);
37606 {
37607 PyThreadState* __tstate = wxPyBeginAllowThreads();
37608 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37609 wxPyEndAllowThreads(__tstate);
37610 if (PyErr_Occurred()) SWIG_fail;
37611 }
37612 resultobj = SWIG_From_int(static_cast< int >(result));
37613 return resultobj;
37614 fail:
37615 return NULL;
37616 }
37617
37618
37619 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37620 PyObject *resultobj = 0;
37621 wxWindow *arg1 = (wxWindow *) 0 ;
37622 int arg2 ;
37623 int result;
37624 void *argp1 = 0 ;
37625 int res1 = 0 ;
37626 int val2 ;
37627 int ecode2 = 0 ;
37628 PyObject * obj0 = 0 ;
37629 PyObject * obj1 = 0 ;
37630 char * kwnames[] = {
37631 (char *) "self",(char *) "orientation", NULL
37632 };
37633
37634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37636 if (!SWIG_IsOK(res1)) {
37637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37638 }
37639 arg1 = reinterpret_cast< wxWindow * >(argp1);
37640 ecode2 = SWIG_AsVal_int(obj1, &val2);
37641 if (!SWIG_IsOK(ecode2)) {
37642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37643 }
37644 arg2 = static_cast< int >(val2);
37645 {
37646 PyThreadState* __tstate = wxPyBeginAllowThreads();
37647 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 resultobj = SWIG_From_int(static_cast< int >(result));
37652 return resultobj;
37653 fail:
37654 return NULL;
37655 }
37656
37657
37658 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37659 PyObject *resultobj = 0;
37660 wxWindow *arg1 = (wxWindow *) 0 ;
37661 int arg2 ;
37662 int arg3 ;
37663 wxRect *arg4 = (wxRect *) NULL ;
37664 void *argp1 = 0 ;
37665 int res1 = 0 ;
37666 int val2 ;
37667 int ecode2 = 0 ;
37668 int val3 ;
37669 int ecode3 = 0 ;
37670 void *argp4 = 0 ;
37671 int res4 = 0 ;
37672 PyObject * obj0 = 0 ;
37673 PyObject * obj1 = 0 ;
37674 PyObject * obj2 = 0 ;
37675 PyObject * obj3 = 0 ;
37676 char * kwnames[] = {
37677 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37678 };
37679
37680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37682 if (!SWIG_IsOK(res1)) {
37683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37684 }
37685 arg1 = reinterpret_cast< wxWindow * >(argp1);
37686 ecode2 = SWIG_AsVal_int(obj1, &val2);
37687 if (!SWIG_IsOK(ecode2)) {
37688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37689 }
37690 arg2 = static_cast< int >(val2);
37691 ecode3 = SWIG_AsVal_int(obj2, &val3);
37692 if (!SWIG_IsOK(ecode3)) {
37693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37694 }
37695 arg3 = static_cast< int >(val3);
37696 if (obj3) {
37697 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37698 if (!SWIG_IsOK(res4)) {
37699 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37700 }
37701 arg4 = reinterpret_cast< wxRect * >(argp4);
37702 }
37703 {
37704 PyThreadState* __tstate = wxPyBeginAllowThreads();
37705 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37706 wxPyEndAllowThreads(__tstate);
37707 if (PyErr_Occurred()) SWIG_fail;
37708 }
37709 resultobj = SWIG_Py_Void();
37710 return resultobj;
37711 fail:
37712 return NULL;
37713 }
37714
37715
37716 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37717 PyObject *resultobj = 0;
37718 wxWindow *arg1 = (wxWindow *) 0 ;
37719 int arg2 ;
37720 bool result;
37721 void *argp1 = 0 ;
37722 int res1 = 0 ;
37723 int val2 ;
37724 int ecode2 = 0 ;
37725 PyObject * obj0 = 0 ;
37726 PyObject * obj1 = 0 ;
37727 char * kwnames[] = {
37728 (char *) "self",(char *) "lines", NULL
37729 };
37730
37731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37733 if (!SWIG_IsOK(res1)) {
37734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37735 }
37736 arg1 = reinterpret_cast< wxWindow * >(argp1);
37737 ecode2 = SWIG_AsVal_int(obj1, &val2);
37738 if (!SWIG_IsOK(ecode2)) {
37739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37740 }
37741 arg2 = static_cast< int >(val2);
37742 {
37743 PyThreadState* __tstate = wxPyBeginAllowThreads();
37744 result = (bool)(arg1)->ScrollLines(arg2);
37745 wxPyEndAllowThreads(__tstate);
37746 if (PyErr_Occurred()) SWIG_fail;
37747 }
37748 {
37749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37750 }
37751 return resultobj;
37752 fail:
37753 return NULL;
37754 }
37755
37756
37757 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37758 PyObject *resultobj = 0;
37759 wxWindow *arg1 = (wxWindow *) 0 ;
37760 int arg2 ;
37761 bool result;
37762 void *argp1 = 0 ;
37763 int res1 = 0 ;
37764 int val2 ;
37765 int ecode2 = 0 ;
37766 PyObject * obj0 = 0 ;
37767 PyObject * obj1 = 0 ;
37768 char * kwnames[] = {
37769 (char *) "self",(char *) "pages", NULL
37770 };
37771
37772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37774 if (!SWIG_IsOK(res1)) {
37775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37776 }
37777 arg1 = reinterpret_cast< wxWindow * >(argp1);
37778 ecode2 = SWIG_AsVal_int(obj1, &val2);
37779 if (!SWIG_IsOK(ecode2)) {
37780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37781 }
37782 arg2 = static_cast< int >(val2);
37783 {
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 result = (bool)(arg1)->ScrollPages(arg2);
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 {
37790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37791 }
37792 return resultobj;
37793 fail:
37794 return NULL;
37795 }
37796
37797
37798 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37799 PyObject *resultobj = 0;
37800 wxWindow *arg1 = (wxWindow *) 0 ;
37801 bool result;
37802 void *argp1 = 0 ;
37803 int res1 = 0 ;
37804 PyObject *swig_obj[1] ;
37805
37806 if (!args) SWIG_fail;
37807 swig_obj[0] = args;
37808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37809 if (!SWIG_IsOK(res1)) {
37810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37811 }
37812 arg1 = reinterpret_cast< wxWindow * >(argp1);
37813 {
37814 PyThreadState* __tstate = wxPyBeginAllowThreads();
37815 result = (bool)(arg1)->LineUp();
37816 wxPyEndAllowThreads(__tstate);
37817 if (PyErr_Occurred()) SWIG_fail;
37818 }
37819 {
37820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37821 }
37822 return resultobj;
37823 fail:
37824 return NULL;
37825 }
37826
37827
37828 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37829 PyObject *resultobj = 0;
37830 wxWindow *arg1 = (wxWindow *) 0 ;
37831 bool result;
37832 void *argp1 = 0 ;
37833 int res1 = 0 ;
37834 PyObject *swig_obj[1] ;
37835
37836 if (!args) SWIG_fail;
37837 swig_obj[0] = args;
37838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37839 if (!SWIG_IsOK(res1)) {
37840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37841 }
37842 arg1 = reinterpret_cast< wxWindow * >(argp1);
37843 {
37844 PyThreadState* __tstate = wxPyBeginAllowThreads();
37845 result = (bool)(arg1)->LineDown();
37846 wxPyEndAllowThreads(__tstate);
37847 if (PyErr_Occurred()) SWIG_fail;
37848 }
37849 {
37850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37851 }
37852 return resultobj;
37853 fail:
37854 return NULL;
37855 }
37856
37857
37858 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37859 PyObject *resultobj = 0;
37860 wxWindow *arg1 = (wxWindow *) 0 ;
37861 bool result;
37862 void *argp1 = 0 ;
37863 int res1 = 0 ;
37864 PyObject *swig_obj[1] ;
37865
37866 if (!args) SWIG_fail;
37867 swig_obj[0] = args;
37868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37869 if (!SWIG_IsOK(res1)) {
37870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37871 }
37872 arg1 = reinterpret_cast< wxWindow * >(argp1);
37873 {
37874 PyThreadState* __tstate = wxPyBeginAllowThreads();
37875 result = (bool)(arg1)->PageUp();
37876 wxPyEndAllowThreads(__tstate);
37877 if (PyErr_Occurred()) SWIG_fail;
37878 }
37879 {
37880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37881 }
37882 return resultobj;
37883 fail:
37884 return NULL;
37885 }
37886
37887
37888 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37889 PyObject *resultobj = 0;
37890 wxWindow *arg1 = (wxWindow *) 0 ;
37891 bool result;
37892 void *argp1 = 0 ;
37893 int res1 = 0 ;
37894 PyObject *swig_obj[1] ;
37895
37896 if (!args) SWIG_fail;
37897 swig_obj[0] = args;
37898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37901 }
37902 arg1 = reinterpret_cast< wxWindow * >(argp1);
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = (bool)(arg1)->PageDown();
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 {
37910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37911 }
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj = 0;
37920 wxWindow *arg1 = (wxWindow *) 0 ;
37921 wxString *arg2 = 0 ;
37922 void *argp1 = 0 ;
37923 int res1 = 0 ;
37924 bool temp2 = false ;
37925 PyObject * obj0 = 0 ;
37926 PyObject * obj1 = 0 ;
37927 char * kwnames[] = {
37928 (char *) "self",(char *) "text", NULL
37929 };
37930
37931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37933 if (!SWIG_IsOK(res1)) {
37934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37935 }
37936 arg1 = reinterpret_cast< wxWindow * >(argp1);
37937 {
37938 arg2 = wxString_in_helper(obj1);
37939 if (arg2 == NULL) SWIG_fail;
37940 temp2 = true;
37941 }
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 (arg1)->SetHelpText((wxString const &)*arg2);
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 resultobj = SWIG_Py_Void();
37949 {
37950 if (temp2)
37951 delete arg2;
37952 }
37953 return resultobj;
37954 fail:
37955 {
37956 if (temp2)
37957 delete arg2;
37958 }
37959 return NULL;
37960 }
37961
37962
37963 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj = 0;
37965 wxWindow *arg1 = (wxWindow *) 0 ;
37966 wxString *arg2 = 0 ;
37967 void *argp1 = 0 ;
37968 int res1 = 0 ;
37969 bool temp2 = false ;
37970 PyObject * obj0 = 0 ;
37971 PyObject * obj1 = 0 ;
37972 char * kwnames[] = {
37973 (char *) "self",(char *) "text", NULL
37974 };
37975
37976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37978 if (!SWIG_IsOK(res1)) {
37979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37980 }
37981 arg1 = reinterpret_cast< wxWindow * >(argp1);
37982 {
37983 arg2 = wxString_in_helper(obj1);
37984 if (arg2 == NULL) SWIG_fail;
37985 temp2 = true;
37986 }
37987 {
37988 PyThreadState* __tstate = wxPyBeginAllowThreads();
37989 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37990 wxPyEndAllowThreads(__tstate);
37991 if (PyErr_Occurred()) SWIG_fail;
37992 }
37993 resultobj = SWIG_Py_Void();
37994 {
37995 if (temp2)
37996 delete arg2;
37997 }
37998 return resultobj;
37999 fail:
38000 {
38001 if (temp2)
38002 delete arg2;
38003 }
38004 return NULL;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj = 0;
38010 wxWindow *arg1 = (wxWindow *) 0 ;
38011 wxPoint *arg2 = 0 ;
38012 wxHelpEvent::Origin arg3 ;
38013 wxString result;
38014 void *argp1 = 0 ;
38015 int res1 = 0 ;
38016 wxPoint temp2 ;
38017 void *argp3 ;
38018 int res3 = 0 ;
38019 PyObject * obj0 = 0 ;
38020 PyObject * obj1 = 0 ;
38021 PyObject * obj2 = 0 ;
38022 char * kwnames[] = {
38023 (char *) "self",(char *) "pt",(char *) "origin", NULL
38024 };
38025
38026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38028 if (!SWIG_IsOK(res1)) {
38029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38030 }
38031 arg1 = reinterpret_cast< wxWindow * >(argp1);
38032 {
38033 arg2 = &temp2;
38034 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38035 }
38036 {
38037 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38038 if (!SWIG_IsOK(res3)) {
38039 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38040 }
38041 if (!argp3) {
38042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38043 } else {
38044 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38045 arg3 = *temp;
38046 if (SWIG_IsNewObj(res3)) delete temp;
38047 }
38048 }
38049 {
38050 PyThreadState* __tstate = wxPyBeginAllowThreads();
38051 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38052 wxPyEndAllowThreads(__tstate);
38053 if (PyErr_Occurred()) SWIG_fail;
38054 }
38055 {
38056 #if wxUSE_UNICODE
38057 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38058 #else
38059 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38060 #endif
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38069 PyObject *resultobj = 0;
38070 wxWindow *arg1 = (wxWindow *) 0 ;
38071 wxString result;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 PyObject *swig_obj[1] ;
38075
38076 if (!args) SWIG_fail;
38077 swig_obj[0] = args;
38078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38079 if (!SWIG_IsOK(res1)) {
38080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38081 }
38082 arg1 = reinterpret_cast< wxWindow * >(argp1);
38083 {
38084 PyThreadState* __tstate = wxPyBeginAllowThreads();
38085 result = ((wxWindow const *)arg1)->GetHelpText();
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 {
38090 #if wxUSE_UNICODE
38091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38092 #else
38093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38094 #endif
38095 }
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj = 0;
38104 wxWindow *arg1 = (wxWindow *) 0 ;
38105 wxString *arg2 = 0 ;
38106 void *argp1 = 0 ;
38107 int res1 = 0 ;
38108 bool temp2 = false ;
38109 PyObject * obj0 = 0 ;
38110 PyObject * obj1 = 0 ;
38111 char * kwnames[] = {
38112 (char *) "self",(char *) "tip", NULL
38113 };
38114
38115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38117 if (!SWIG_IsOK(res1)) {
38118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38119 }
38120 arg1 = reinterpret_cast< wxWindow * >(argp1);
38121 {
38122 arg2 = wxString_in_helper(obj1);
38123 if (arg2 == NULL) SWIG_fail;
38124 temp2 = true;
38125 }
38126 {
38127 PyThreadState* __tstate = wxPyBeginAllowThreads();
38128 (arg1)->SetToolTip((wxString const &)*arg2);
38129 wxPyEndAllowThreads(__tstate);
38130 if (PyErr_Occurred()) SWIG_fail;
38131 }
38132 resultobj = SWIG_Py_Void();
38133 {
38134 if (temp2)
38135 delete arg2;
38136 }
38137 return resultobj;
38138 fail:
38139 {
38140 if (temp2)
38141 delete arg2;
38142 }
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38148 PyObject *resultobj = 0;
38149 wxWindow *arg1 = (wxWindow *) 0 ;
38150 wxToolTip *arg2 = (wxToolTip *) 0 ;
38151 void *argp1 = 0 ;
38152 int res1 = 0 ;
38153 int res2 = 0 ;
38154 PyObject * obj0 = 0 ;
38155 PyObject * obj1 = 0 ;
38156 char * kwnames[] = {
38157 (char *) "self",(char *) "tip", NULL
38158 };
38159
38160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38162 if (!SWIG_IsOK(res1)) {
38163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38164 }
38165 arg1 = reinterpret_cast< wxWindow * >(argp1);
38166 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38167 if (!SWIG_IsOK(res2)) {
38168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38169 }
38170 {
38171 PyThreadState* __tstate = wxPyBeginAllowThreads();
38172 (arg1)->SetToolTip(arg2);
38173 wxPyEndAllowThreads(__tstate);
38174 if (PyErr_Occurred()) SWIG_fail;
38175 }
38176 resultobj = SWIG_Py_Void();
38177 return resultobj;
38178 fail:
38179 return NULL;
38180 }
38181
38182
38183 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38184 PyObject *resultobj = 0;
38185 wxWindow *arg1 = (wxWindow *) 0 ;
38186 wxToolTip *result = 0 ;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 PyObject *swig_obj[1] ;
38190
38191 if (!args) SWIG_fail;
38192 swig_obj[0] = args;
38193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38196 }
38197 arg1 = reinterpret_cast< wxWindow * >(argp1);
38198 {
38199 PyThreadState* __tstate = wxPyBeginAllowThreads();
38200 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38201 wxPyEndAllowThreads(__tstate);
38202 if (PyErr_Occurred()) SWIG_fail;
38203 }
38204 {
38205 resultobj = wxPyMake_wxObject(result, (bool)0);
38206 }
38207 return resultobj;
38208 fail:
38209 return NULL;
38210 }
38211
38212
38213 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38214 PyObject *resultobj = 0;
38215 wxWindow *arg1 = (wxWindow *) 0 ;
38216 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38217 void *argp1 = 0 ;
38218 int res1 = 0 ;
38219 int res2 = 0 ;
38220 PyObject * obj0 = 0 ;
38221 PyObject * obj1 = 0 ;
38222 char * kwnames[] = {
38223 (char *) "self",(char *) "dropTarget", NULL
38224 };
38225
38226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38228 if (!SWIG_IsOK(res1)) {
38229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38230 }
38231 arg1 = reinterpret_cast< wxWindow * >(argp1);
38232 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38233 if (!SWIG_IsOK(res2)) {
38234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38235 }
38236 {
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 (arg1)->SetDropTarget(arg2);
38239 wxPyEndAllowThreads(__tstate);
38240 if (PyErr_Occurred()) SWIG_fail;
38241 }
38242 resultobj = SWIG_Py_Void();
38243 return resultobj;
38244 fail:
38245 return NULL;
38246 }
38247
38248
38249 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38250 PyObject *resultobj = 0;
38251 wxWindow *arg1 = (wxWindow *) 0 ;
38252 wxPyDropTarget *result = 0 ;
38253 void *argp1 = 0 ;
38254 int res1 = 0 ;
38255 PyObject *swig_obj[1] ;
38256
38257 if (!args) SWIG_fail;
38258 swig_obj[0] = args;
38259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38260 if (!SWIG_IsOK(res1)) {
38261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38262 }
38263 arg1 = reinterpret_cast< wxWindow * >(argp1);
38264 {
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38267 wxPyEndAllowThreads(__tstate);
38268 if (PyErr_Occurred()) SWIG_fail;
38269 }
38270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38271 return resultobj;
38272 fail:
38273 return NULL;
38274 }
38275
38276
38277 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38278 PyObject *resultobj = 0;
38279 wxWindow *arg1 = (wxWindow *) 0 ;
38280 bool arg2 ;
38281 void *argp1 = 0 ;
38282 int res1 = 0 ;
38283 bool val2 ;
38284 int ecode2 = 0 ;
38285 PyObject * obj0 = 0 ;
38286 PyObject * obj1 = 0 ;
38287 char * kwnames[] = {
38288 (char *) "self",(char *) "accept", NULL
38289 };
38290
38291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38293 if (!SWIG_IsOK(res1)) {
38294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38295 }
38296 arg1 = reinterpret_cast< wxWindow * >(argp1);
38297 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38298 if (!SWIG_IsOK(ecode2)) {
38299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38300 }
38301 arg2 = static_cast< bool >(val2);
38302 {
38303 PyThreadState* __tstate = wxPyBeginAllowThreads();
38304 wxWindow_DragAcceptFiles(arg1,arg2);
38305 wxPyEndAllowThreads(__tstate);
38306 if (PyErr_Occurred()) SWIG_fail;
38307 }
38308 resultobj = SWIG_Py_Void();
38309 return resultobj;
38310 fail:
38311 return NULL;
38312 }
38313
38314
38315 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38316 PyObject *resultobj = 0;
38317 wxWindow *arg1 = (wxWindow *) 0 ;
38318 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38319 void *argp1 = 0 ;
38320 int res1 = 0 ;
38321 int res2 = 0 ;
38322 PyObject * obj0 = 0 ;
38323 PyObject * obj1 = 0 ;
38324 char * kwnames[] = {
38325 (char *) "self",(char *) "constraints", NULL
38326 };
38327
38328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38330 if (!SWIG_IsOK(res1)) {
38331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38332 }
38333 arg1 = reinterpret_cast< wxWindow * >(argp1);
38334 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38335 if (!SWIG_IsOK(res2)) {
38336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38337 }
38338 {
38339 PyThreadState* __tstate = wxPyBeginAllowThreads();
38340 (arg1)->SetConstraints(arg2);
38341 wxPyEndAllowThreads(__tstate);
38342 if (PyErr_Occurred()) SWIG_fail;
38343 }
38344 resultobj = SWIG_Py_Void();
38345 return resultobj;
38346 fail:
38347 return NULL;
38348 }
38349
38350
38351 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38352 PyObject *resultobj = 0;
38353 wxWindow *arg1 = (wxWindow *) 0 ;
38354 wxLayoutConstraints *result = 0 ;
38355 void *argp1 = 0 ;
38356 int res1 = 0 ;
38357 PyObject *swig_obj[1] ;
38358
38359 if (!args) SWIG_fail;
38360 swig_obj[0] = args;
38361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38362 if (!SWIG_IsOK(res1)) {
38363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38364 }
38365 arg1 = reinterpret_cast< wxWindow * >(argp1);
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38369 wxPyEndAllowThreads(__tstate);
38370 if (PyErr_Occurred()) SWIG_fail;
38371 }
38372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38373 return resultobj;
38374 fail:
38375 return NULL;
38376 }
38377
38378
38379 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38380 PyObject *resultobj = 0;
38381 wxWindow *arg1 = (wxWindow *) 0 ;
38382 bool arg2 ;
38383 void *argp1 = 0 ;
38384 int res1 = 0 ;
38385 bool val2 ;
38386 int ecode2 = 0 ;
38387 PyObject * obj0 = 0 ;
38388 PyObject * obj1 = 0 ;
38389 char * kwnames[] = {
38390 (char *) "self",(char *) "autoLayout", NULL
38391 };
38392
38393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38395 if (!SWIG_IsOK(res1)) {
38396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38397 }
38398 arg1 = reinterpret_cast< wxWindow * >(argp1);
38399 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38400 if (!SWIG_IsOK(ecode2)) {
38401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38402 }
38403 arg2 = static_cast< bool >(val2);
38404 {
38405 PyThreadState* __tstate = wxPyBeginAllowThreads();
38406 (arg1)->SetAutoLayout(arg2);
38407 wxPyEndAllowThreads(__tstate);
38408 if (PyErr_Occurred()) SWIG_fail;
38409 }
38410 resultobj = SWIG_Py_Void();
38411 return resultobj;
38412 fail:
38413 return NULL;
38414 }
38415
38416
38417 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38418 PyObject *resultobj = 0;
38419 wxWindow *arg1 = (wxWindow *) 0 ;
38420 bool result;
38421 void *argp1 = 0 ;
38422 int res1 = 0 ;
38423 PyObject *swig_obj[1] ;
38424
38425 if (!args) SWIG_fail;
38426 swig_obj[0] = args;
38427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38428 if (!SWIG_IsOK(res1)) {
38429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38430 }
38431 arg1 = reinterpret_cast< wxWindow * >(argp1);
38432 {
38433 PyThreadState* __tstate = wxPyBeginAllowThreads();
38434 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38435 wxPyEndAllowThreads(__tstate);
38436 if (PyErr_Occurred()) SWIG_fail;
38437 }
38438 {
38439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38440 }
38441 return resultobj;
38442 fail:
38443 return NULL;
38444 }
38445
38446
38447 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38448 PyObject *resultobj = 0;
38449 wxWindow *arg1 = (wxWindow *) 0 ;
38450 bool result;
38451 void *argp1 = 0 ;
38452 int res1 = 0 ;
38453 PyObject *swig_obj[1] ;
38454
38455 if (!args) SWIG_fail;
38456 swig_obj[0] = args;
38457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38458 if (!SWIG_IsOK(res1)) {
38459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38460 }
38461 arg1 = reinterpret_cast< wxWindow * >(argp1);
38462 {
38463 PyThreadState* __tstate = wxPyBeginAllowThreads();
38464 result = (bool)(arg1)->Layout();
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 {
38469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38470 }
38471 return resultobj;
38472 fail:
38473 return NULL;
38474 }
38475
38476
38477 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38478 PyObject *resultobj = 0;
38479 wxWindow *arg1 = (wxWindow *) 0 ;
38480 wxSizer *arg2 = (wxSizer *) 0 ;
38481 bool arg3 = (bool) true ;
38482 void *argp1 = 0 ;
38483 int res1 = 0 ;
38484 int res2 = 0 ;
38485 bool val3 ;
38486 int ecode3 = 0 ;
38487 PyObject * obj0 = 0 ;
38488 PyObject * obj1 = 0 ;
38489 PyObject * obj2 = 0 ;
38490 char * kwnames[] = {
38491 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38492 };
38493
38494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38496 if (!SWIG_IsOK(res1)) {
38497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38498 }
38499 arg1 = reinterpret_cast< wxWindow * >(argp1);
38500 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38501 if (!SWIG_IsOK(res2)) {
38502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38503 }
38504 if (obj2) {
38505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38506 if (!SWIG_IsOK(ecode3)) {
38507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38508 }
38509 arg3 = static_cast< bool >(val3);
38510 }
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 (arg1)->SetSizer(arg2,arg3);
38514 wxPyEndAllowThreads(__tstate);
38515 if (PyErr_Occurred()) SWIG_fail;
38516 }
38517 resultobj = SWIG_Py_Void();
38518 return resultobj;
38519 fail:
38520 return NULL;
38521 }
38522
38523
38524 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38525 PyObject *resultobj = 0;
38526 wxWindow *arg1 = (wxWindow *) 0 ;
38527 wxSizer *arg2 = (wxSizer *) 0 ;
38528 bool arg3 = (bool) true ;
38529 void *argp1 = 0 ;
38530 int res1 = 0 ;
38531 int res2 = 0 ;
38532 bool val3 ;
38533 int ecode3 = 0 ;
38534 PyObject * obj0 = 0 ;
38535 PyObject * obj1 = 0 ;
38536 PyObject * obj2 = 0 ;
38537 char * kwnames[] = {
38538 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38539 };
38540
38541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38543 if (!SWIG_IsOK(res1)) {
38544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38545 }
38546 arg1 = reinterpret_cast< wxWindow * >(argp1);
38547 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38548 if (!SWIG_IsOK(res2)) {
38549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38550 }
38551 if (obj2) {
38552 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38553 if (!SWIG_IsOK(ecode3)) {
38554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38555 }
38556 arg3 = static_cast< bool >(val3);
38557 }
38558 {
38559 PyThreadState* __tstate = wxPyBeginAllowThreads();
38560 (arg1)->SetSizerAndFit(arg2,arg3);
38561 wxPyEndAllowThreads(__tstate);
38562 if (PyErr_Occurred()) SWIG_fail;
38563 }
38564 resultobj = SWIG_Py_Void();
38565 return resultobj;
38566 fail:
38567 return NULL;
38568 }
38569
38570
38571 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38572 PyObject *resultobj = 0;
38573 wxWindow *arg1 = (wxWindow *) 0 ;
38574 wxSizer *result = 0 ;
38575 void *argp1 = 0 ;
38576 int res1 = 0 ;
38577 PyObject *swig_obj[1] ;
38578
38579 if (!args) SWIG_fail;
38580 swig_obj[0] = args;
38581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38582 if (!SWIG_IsOK(res1)) {
38583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38584 }
38585 arg1 = reinterpret_cast< wxWindow * >(argp1);
38586 {
38587 PyThreadState* __tstate = wxPyBeginAllowThreads();
38588 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38589 wxPyEndAllowThreads(__tstate);
38590 if (PyErr_Occurred()) SWIG_fail;
38591 }
38592 {
38593 resultobj = wxPyMake_wxObject(result, (bool)0);
38594 }
38595 return resultobj;
38596 fail:
38597 return NULL;
38598 }
38599
38600
38601 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38602 PyObject *resultobj = 0;
38603 wxWindow *arg1 = (wxWindow *) 0 ;
38604 wxSizer *arg2 = (wxSizer *) 0 ;
38605 void *argp1 = 0 ;
38606 int res1 = 0 ;
38607 void *argp2 = 0 ;
38608 int res2 = 0 ;
38609 PyObject * obj0 = 0 ;
38610 PyObject * obj1 = 0 ;
38611 char * kwnames[] = {
38612 (char *) "self",(char *) "sizer", NULL
38613 };
38614
38615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38617 if (!SWIG_IsOK(res1)) {
38618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38619 }
38620 arg1 = reinterpret_cast< wxWindow * >(argp1);
38621 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38622 if (!SWIG_IsOK(res2)) {
38623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38624 }
38625 arg2 = reinterpret_cast< wxSizer * >(argp2);
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 (arg1)->SetContainingSizer(arg2);
38629 wxPyEndAllowThreads(__tstate);
38630 if (PyErr_Occurred()) SWIG_fail;
38631 }
38632 resultobj = SWIG_Py_Void();
38633 return resultobj;
38634 fail:
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38640 PyObject *resultobj = 0;
38641 wxWindow *arg1 = (wxWindow *) 0 ;
38642 wxSizer *result = 0 ;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 PyObject *swig_obj[1] ;
38646
38647 if (!args) SWIG_fail;
38648 swig_obj[0] = args;
38649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38650 if (!SWIG_IsOK(res1)) {
38651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38652 }
38653 arg1 = reinterpret_cast< wxWindow * >(argp1);
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 {
38661 resultobj = wxPyMake_wxObject(result, (bool)0);
38662 }
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38670 PyObject *resultobj = 0;
38671 wxWindow *arg1 = (wxWindow *) 0 ;
38672 void *argp1 = 0 ;
38673 int res1 = 0 ;
38674 PyObject *swig_obj[1] ;
38675
38676 if (!args) SWIG_fail;
38677 swig_obj[0] = args;
38678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38679 if (!SWIG_IsOK(res1)) {
38680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38681 }
38682 arg1 = reinterpret_cast< wxWindow * >(argp1);
38683 {
38684 PyThreadState* __tstate = wxPyBeginAllowThreads();
38685 (arg1)->InheritAttributes();
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 resultobj = SWIG_Py_Void();
38690 return resultobj;
38691 fail:
38692 return NULL;
38693 }
38694
38695
38696 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38697 PyObject *resultobj = 0;
38698 wxWindow *arg1 = (wxWindow *) 0 ;
38699 bool result;
38700 void *argp1 = 0 ;
38701 int res1 = 0 ;
38702 PyObject *swig_obj[1] ;
38703
38704 if (!args) SWIG_fail;
38705 swig_obj[0] = args;
38706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38707 if (!SWIG_IsOK(res1)) {
38708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38709 }
38710 arg1 = reinterpret_cast< wxWindow * >(argp1);
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38714 wxPyEndAllowThreads(__tstate);
38715 if (PyErr_Occurred()) SWIG_fail;
38716 }
38717 {
38718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38719 }
38720 return resultobj;
38721 fail:
38722 return NULL;
38723 }
38724
38725
38726 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38727 PyObject *resultobj = 0;
38728 wxWindow *arg1 = (wxWindow *) 0 ;
38729 bool result;
38730 void *argp1 = 0 ;
38731 int res1 = 0 ;
38732 PyObject *swig_obj[1] ;
38733
38734 if (!args) SWIG_fail;
38735 swig_obj[0] = args;
38736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38737 if (!SWIG_IsOK(res1)) {
38738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38739 }
38740 arg1 = reinterpret_cast< wxWindow * >(argp1);
38741 {
38742 PyThreadState* __tstate = wxPyBeginAllowThreads();
38743 result = (bool)(arg1)->CanSetTransparent();
38744 wxPyEndAllowThreads(__tstate);
38745 if (PyErr_Occurred()) SWIG_fail;
38746 }
38747 {
38748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38749 }
38750 return resultobj;
38751 fail:
38752 return NULL;
38753 }
38754
38755
38756 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38757 PyObject *resultobj = 0;
38758 wxWindow *arg1 = (wxWindow *) 0 ;
38759 byte arg2 ;
38760 bool result;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 unsigned char val2 ;
38764 int ecode2 = 0 ;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 char * kwnames[] = {
38768 (char *) "self",(char *) "alpha", NULL
38769 };
38770
38771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38773 if (!SWIG_IsOK(res1)) {
38774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38775 }
38776 arg1 = reinterpret_cast< wxWindow * >(argp1);
38777 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38778 if (!SWIG_IsOK(ecode2)) {
38779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38780 }
38781 arg2 = static_cast< byte >(val2);
38782 {
38783 PyThreadState* __tstate = wxPyBeginAllowThreads();
38784 result = (bool)(arg1)->SetTransparent(arg2);
38785 wxPyEndAllowThreads(__tstate);
38786 if (PyErr_Occurred()) SWIG_fail;
38787 }
38788 {
38789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38790 }
38791 return resultobj;
38792 fail:
38793 return NULL;
38794 }
38795
38796
38797 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38798 PyObject *obj;
38799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38800 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38801 return SWIG_Py_Void();
38802 }
38803
38804 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38805 return SWIG_Python_InitShadowInstance(args);
38806 }
38807
38808 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38809 PyObject *resultobj = 0;
38810 long arg1 ;
38811 wxWindow *arg2 = (wxWindow *) NULL ;
38812 wxWindow *result = 0 ;
38813 long val1 ;
38814 int ecode1 = 0 ;
38815 void *argp2 = 0 ;
38816 int res2 = 0 ;
38817 PyObject * obj0 = 0 ;
38818 PyObject * obj1 = 0 ;
38819 char * kwnames[] = {
38820 (char *) "id",(char *) "parent", NULL
38821 };
38822
38823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38824 ecode1 = SWIG_AsVal_long(obj0, &val1);
38825 if (!SWIG_IsOK(ecode1)) {
38826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38827 }
38828 arg1 = static_cast< long >(val1);
38829 if (obj1) {
38830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38831 if (!SWIG_IsOK(res2)) {
38832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38833 }
38834 arg2 = reinterpret_cast< wxWindow * >(argp2);
38835 }
38836 {
38837 if (!wxPyCheckForApp()) SWIG_fail;
38838 PyThreadState* __tstate = wxPyBeginAllowThreads();
38839 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38840 wxPyEndAllowThreads(__tstate);
38841 if (PyErr_Occurred()) SWIG_fail;
38842 }
38843 {
38844 resultobj = wxPyMake_wxObject(result, 0);
38845 }
38846 return resultobj;
38847 fail:
38848 return NULL;
38849 }
38850
38851
38852 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38853 PyObject *resultobj = 0;
38854 wxString *arg1 = 0 ;
38855 wxWindow *arg2 = (wxWindow *) NULL ;
38856 wxWindow *result = 0 ;
38857 bool temp1 = false ;
38858 void *argp2 = 0 ;
38859 int res2 = 0 ;
38860 PyObject * obj0 = 0 ;
38861 PyObject * obj1 = 0 ;
38862 char * kwnames[] = {
38863 (char *) "name",(char *) "parent", NULL
38864 };
38865
38866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38867 {
38868 arg1 = wxString_in_helper(obj0);
38869 if (arg1 == NULL) SWIG_fail;
38870 temp1 = true;
38871 }
38872 if (obj1) {
38873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38874 if (!SWIG_IsOK(res2)) {
38875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38876 }
38877 arg2 = reinterpret_cast< wxWindow * >(argp2);
38878 }
38879 {
38880 if (!wxPyCheckForApp()) SWIG_fail;
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38883 wxPyEndAllowThreads(__tstate);
38884 if (PyErr_Occurred()) SWIG_fail;
38885 }
38886 {
38887 resultobj = wxPyMake_wxObject(result, 0);
38888 }
38889 {
38890 if (temp1)
38891 delete arg1;
38892 }
38893 return resultobj;
38894 fail:
38895 {
38896 if (temp1)
38897 delete arg1;
38898 }
38899 return NULL;
38900 }
38901
38902
38903 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38904 PyObject *resultobj = 0;
38905 wxString *arg1 = 0 ;
38906 wxWindow *arg2 = (wxWindow *) NULL ;
38907 wxWindow *result = 0 ;
38908 bool temp1 = false ;
38909 void *argp2 = 0 ;
38910 int res2 = 0 ;
38911 PyObject * obj0 = 0 ;
38912 PyObject * obj1 = 0 ;
38913 char * kwnames[] = {
38914 (char *) "label",(char *) "parent", NULL
38915 };
38916
38917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38918 {
38919 arg1 = wxString_in_helper(obj0);
38920 if (arg1 == NULL) SWIG_fail;
38921 temp1 = true;
38922 }
38923 if (obj1) {
38924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38925 if (!SWIG_IsOK(res2)) {
38926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38927 }
38928 arg2 = reinterpret_cast< wxWindow * >(argp2);
38929 }
38930 {
38931 if (!wxPyCheckForApp()) SWIG_fail;
38932 PyThreadState* __tstate = wxPyBeginAllowThreads();
38933 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38934 wxPyEndAllowThreads(__tstate);
38935 if (PyErr_Occurred()) SWIG_fail;
38936 }
38937 {
38938 resultobj = wxPyMake_wxObject(result, 0);
38939 }
38940 {
38941 if (temp1)
38942 delete arg1;
38943 }
38944 return resultobj;
38945 fail:
38946 {
38947 if (temp1)
38948 delete arg1;
38949 }
38950 return NULL;
38951 }
38952
38953
38954 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38955 PyObject *resultobj = 0;
38956 wxWindow *arg1 = (wxWindow *) 0 ;
38957 unsigned long arg2 ;
38958 wxWindow *result = 0 ;
38959 void *argp1 = 0 ;
38960 int res1 = 0 ;
38961 unsigned long val2 ;
38962 int ecode2 = 0 ;
38963 PyObject * obj0 = 0 ;
38964 PyObject * obj1 = 0 ;
38965 char * kwnames[] = {
38966 (char *) "parent",(char *) "_hWnd", NULL
38967 };
38968
38969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38971 if (!SWIG_IsOK(res1)) {
38972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38973 }
38974 arg1 = reinterpret_cast< wxWindow * >(argp1);
38975 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38976 if (!SWIG_IsOK(ecode2)) {
38977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38978 }
38979 arg2 = static_cast< unsigned long >(val2);
38980 {
38981 PyThreadState* __tstate = wxPyBeginAllowThreads();
38982 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38983 wxPyEndAllowThreads(__tstate);
38984 if (PyErr_Occurred()) SWIG_fail;
38985 }
38986 {
38987 resultobj = wxPyMake_wxObject(result, 0);
38988 }
38989 return resultobj;
38990 fail:
38991 return NULL;
38992 }
38993
38994
38995 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38996 PyObject *resultobj = 0;
38997 PyObject *result = 0 ;
38998
38999 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39000 {
39001 PyThreadState* __tstate = wxPyBeginAllowThreads();
39002 result = (PyObject *)GetTopLevelWindows();
39003 wxPyEndAllowThreads(__tstate);
39004 if (PyErr_Occurred()) SWIG_fail;
39005 }
39006 resultobj = result;
39007 return resultobj;
39008 fail:
39009 return NULL;
39010 }
39011
39012
39013 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39014 PyObject *resultobj = 0;
39015 wxValidator *result = 0 ;
39016
39017 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39018 {
39019 PyThreadState* __tstate = wxPyBeginAllowThreads();
39020 result = (wxValidator *)new wxValidator();
39021 wxPyEndAllowThreads(__tstate);
39022 if (PyErr_Occurred()) SWIG_fail;
39023 }
39024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39025 return resultobj;
39026 fail:
39027 return NULL;
39028 }
39029
39030
39031 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39032 PyObject *resultobj = 0;
39033 wxValidator *arg1 = (wxValidator *) 0 ;
39034 wxValidator *result = 0 ;
39035 void *argp1 = 0 ;
39036 int res1 = 0 ;
39037 PyObject *swig_obj[1] ;
39038
39039 if (!args) SWIG_fail;
39040 swig_obj[0] = args;
39041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39042 if (!SWIG_IsOK(res1)) {
39043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39044 }
39045 arg1 = reinterpret_cast< wxValidator * >(argp1);
39046 {
39047 PyThreadState* __tstate = wxPyBeginAllowThreads();
39048 result = (wxValidator *)(arg1)->Clone();
39049 wxPyEndAllowThreads(__tstate);
39050 if (PyErr_Occurred()) SWIG_fail;
39051 }
39052 {
39053 resultobj = wxPyMake_wxObject(result, 0);
39054 }
39055 return resultobj;
39056 fail:
39057 return NULL;
39058 }
39059
39060
39061 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39062 PyObject *resultobj = 0;
39063 wxValidator *arg1 = (wxValidator *) 0 ;
39064 wxWindow *arg2 = (wxWindow *) 0 ;
39065 bool result;
39066 void *argp1 = 0 ;
39067 int res1 = 0 ;
39068 void *argp2 = 0 ;
39069 int res2 = 0 ;
39070 PyObject * obj0 = 0 ;
39071 PyObject * obj1 = 0 ;
39072 char * kwnames[] = {
39073 (char *) "self",(char *) "parent", NULL
39074 };
39075
39076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39078 if (!SWIG_IsOK(res1)) {
39079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39080 }
39081 arg1 = reinterpret_cast< wxValidator * >(argp1);
39082 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39083 if (!SWIG_IsOK(res2)) {
39084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39085 }
39086 arg2 = reinterpret_cast< wxWindow * >(argp2);
39087 {
39088 PyThreadState* __tstate = wxPyBeginAllowThreads();
39089 result = (bool)(arg1)->Validate(arg2);
39090 wxPyEndAllowThreads(__tstate);
39091 if (PyErr_Occurred()) SWIG_fail;
39092 }
39093 {
39094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39095 }
39096 return resultobj;
39097 fail:
39098 return NULL;
39099 }
39100
39101
39102 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39103 PyObject *resultobj = 0;
39104 wxValidator *arg1 = (wxValidator *) 0 ;
39105 bool result;
39106 void *argp1 = 0 ;
39107 int res1 = 0 ;
39108 PyObject *swig_obj[1] ;
39109
39110 if (!args) SWIG_fail;
39111 swig_obj[0] = args;
39112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39113 if (!SWIG_IsOK(res1)) {
39114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39115 }
39116 arg1 = reinterpret_cast< wxValidator * >(argp1);
39117 {
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (bool)(arg1)->TransferToWindow();
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 {
39124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39125 }
39126 return resultobj;
39127 fail:
39128 return NULL;
39129 }
39130
39131
39132 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39133 PyObject *resultobj = 0;
39134 wxValidator *arg1 = (wxValidator *) 0 ;
39135 bool result;
39136 void *argp1 = 0 ;
39137 int res1 = 0 ;
39138 PyObject *swig_obj[1] ;
39139
39140 if (!args) SWIG_fail;
39141 swig_obj[0] = args;
39142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39143 if (!SWIG_IsOK(res1)) {
39144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39145 }
39146 arg1 = reinterpret_cast< wxValidator * >(argp1);
39147 {
39148 PyThreadState* __tstate = wxPyBeginAllowThreads();
39149 result = (bool)(arg1)->TransferFromWindow();
39150 wxPyEndAllowThreads(__tstate);
39151 if (PyErr_Occurred()) SWIG_fail;
39152 }
39153 {
39154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39155 }
39156 return resultobj;
39157 fail:
39158 return NULL;
39159 }
39160
39161
39162 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39163 PyObject *resultobj = 0;
39164 wxValidator *arg1 = (wxValidator *) 0 ;
39165 wxWindow *result = 0 ;
39166 void *argp1 = 0 ;
39167 int res1 = 0 ;
39168 PyObject *swig_obj[1] ;
39169
39170 if (!args) SWIG_fail;
39171 swig_obj[0] = args;
39172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39173 if (!SWIG_IsOK(res1)) {
39174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39175 }
39176 arg1 = reinterpret_cast< wxValidator * >(argp1);
39177 {
39178 PyThreadState* __tstate = wxPyBeginAllowThreads();
39179 result = (wxWindow *)(arg1)->GetWindow();
39180 wxPyEndAllowThreads(__tstate);
39181 if (PyErr_Occurred()) SWIG_fail;
39182 }
39183 {
39184 resultobj = wxPyMake_wxObject(result, 0);
39185 }
39186 return resultobj;
39187 fail:
39188 return NULL;
39189 }
39190
39191
39192 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39193 PyObject *resultobj = 0;
39194 wxValidator *arg1 = (wxValidator *) 0 ;
39195 wxWindow *arg2 = (wxWindow *) 0 ;
39196 void *argp1 = 0 ;
39197 int res1 = 0 ;
39198 void *argp2 = 0 ;
39199 int res2 = 0 ;
39200 PyObject * obj0 = 0 ;
39201 PyObject * obj1 = 0 ;
39202 char * kwnames[] = {
39203 (char *) "self",(char *) "window", NULL
39204 };
39205
39206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39208 if (!SWIG_IsOK(res1)) {
39209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39210 }
39211 arg1 = reinterpret_cast< wxValidator * >(argp1);
39212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39213 if (!SWIG_IsOK(res2)) {
39214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39215 }
39216 arg2 = reinterpret_cast< wxWindow * >(argp2);
39217 {
39218 PyThreadState* __tstate = wxPyBeginAllowThreads();
39219 (arg1)->SetWindow(arg2);
39220 wxPyEndAllowThreads(__tstate);
39221 if (PyErr_Occurred()) SWIG_fail;
39222 }
39223 resultobj = SWIG_Py_Void();
39224 return resultobj;
39225 fail:
39226 return NULL;
39227 }
39228
39229
39230 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39231 PyObject *resultobj = 0;
39232 bool result;
39233
39234 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39235 {
39236 PyThreadState* __tstate = wxPyBeginAllowThreads();
39237 result = (bool)wxValidator::IsSilent();
39238 wxPyEndAllowThreads(__tstate);
39239 if (PyErr_Occurred()) SWIG_fail;
39240 }
39241 {
39242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39243 }
39244 return resultobj;
39245 fail:
39246 return NULL;
39247 }
39248
39249
39250 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39251 PyObject *resultobj = 0;
39252 int arg1 = (int) true ;
39253 int val1 ;
39254 int ecode1 = 0 ;
39255 PyObject * obj0 = 0 ;
39256 char * kwnames[] = {
39257 (char *) "doIt", NULL
39258 };
39259
39260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39261 if (obj0) {
39262 ecode1 = SWIG_AsVal_int(obj0, &val1);
39263 if (!SWIG_IsOK(ecode1)) {
39264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39265 }
39266 arg1 = static_cast< int >(val1);
39267 }
39268 {
39269 PyThreadState* __tstate = wxPyBeginAllowThreads();
39270 wxValidator::SetBellOnError(arg1);
39271 wxPyEndAllowThreads(__tstate);
39272 if (PyErr_Occurred()) SWIG_fail;
39273 }
39274 resultobj = SWIG_Py_Void();
39275 return resultobj;
39276 fail:
39277 return NULL;
39278 }
39279
39280
39281 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39282 PyObject *obj;
39283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39284 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39285 return SWIG_Py_Void();
39286 }
39287
39288 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39289 return SWIG_Python_InitShadowInstance(args);
39290 }
39291
39292 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39293 PyObject *resultobj = 0;
39294 wxPyValidator *result = 0 ;
39295
39296 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39297 {
39298 PyThreadState* __tstate = wxPyBeginAllowThreads();
39299 result = (wxPyValidator *)new wxPyValidator();
39300 wxPyEndAllowThreads(__tstate);
39301 if (PyErr_Occurred()) SWIG_fail;
39302 }
39303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39304 return resultobj;
39305 fail:
39306 return NULL;
39307 }
39308
39309
39310 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39311 PyObject *resultobj = 0;
39312 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39313 PyObject *arg2 = (PyObject *) 0 ;
39314 PyObject *arg3 = (PyObject *) 0 ;
39315 int arg4 = (int) true ;
39316 void *argp1 = 0 ;
39317 int res1 = 0 ;
39318 int val4 ;
39319 int ecode4 = 0 ;
39320 PyObject * obj0 = 0 ;
39321 PyObject * obj1 = 0 ;
39322 PyObject * obj2 = 0 ;
39323 PyObject * obj3 = 0 ;
39324 char * kwnames[] = {
39325 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39326 };
39327
39328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39330 if (!SWIG_IsOK(res1)) {
39331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39332 }
39333 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39334 arg2 = obj1;
39335 arg3 = obj2;
39336 if (obj3) {
39337 ecode4 = SWIG_AsVal_int(obj3, &val4);
39338 if (!SWIG_IsOK(ecode4)) {
39339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39340 }
39341 arg4 = static_cast< int >(val4);
39342 }
39343 {
39344 PyThreadState* __tstate = wxPyBeginAllowThreads();
39345 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39346 wxPyEndAllowThreads(__tstate);
39347 if (PyErr_Occurred()) SWIG_fail;
39348 }
39349 resultobj = SWIG_Py_Void();
39350 return resultobj;
39351 fail:
39352 return NULL;
39353 }
39354
39355
39356 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39357 PyObject *obj;
39358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39359 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39360 return SWIG_Py_Void();
39361 }
39362
39363 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39364 return SWIG_Python_InitShadowInstance(args);
39365 }
39366
39367 SWIGINTERN int DefaultValidator_set(PyObject *) {
39368 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39369 return 1;
39370 }
39371
39372
39373 SWIGINTERN PyObject *DefaultValidator_get(void) {
39374 PyObject *pyobj = 0;
39375
39376 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39377 return pyobj;
39378 }
39379
39380
39381 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39382 PyObject *resultobj = 0;
39383 wxString const &arg1_defvalue = wxPyEmptyString ;
39384 wxString *arg1 = (wxString *) &arg1_defvalue ;
39385 long arg2 = (long) 0 ;
39386 wxMenu *result = 0 ;
39387 bool temp1 = false ;
39388 long val2 ;
39389 int ecode2 = 0 ;
39390 PyObject * obj0 = 0 ;
39391 PyObject * obj1 = 0 ;
39392 char * kwnames[] = {
39393 (char *) "title",(char *) "style", NULL
39394 };
39395
39396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39397 if (obj0) {
39398 {
39399 arg1 = wxString_in_helper(obj0);
39400 if (arg1 == NULL) SWIG_fail;
39401 temp1 = true;
39402 }
39403 }
39404 if (obj1) {
39405 ecode2 = SWIG_AsVal_long(obj1, &val2);
39406 if (!SWIG_IsOK(ecode2)) {
39407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39408 }
39409 arg2 = static_cast< long >(val2);
39410 }
39411 {
39412 if (!wxPyCheckForApp()) SWIG_fail;
39413 PyThreadState* __tstate = wxPyBeginAllowThreads();
39414 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39419 {
39420 if (temp1)
39421 delete arg1;
39422 }
39423 return resultobj;
39424 fail:
39425 {
39426 if (temp1)
39427 delete arg1;
39428 }
39429 return NULL;
39430 }
39431
39432
39433 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39434 PyObject *resultobj = 0;
39435 wxMenu *arg1 = (wxMenu *) 0 ;
39436 int arg2 ;
39437 wxString const &arg3_defvalue = wxPyEmptyString ;
39438 wxString *arg3 = (wxString *) &arg3_defvalue ;
39439 wxString const &arg4_defvalue = wxPyEmptyString ;
39440 wxString *arg4 = (wxString *) &arg4_defvalue ;
39441 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39442 wxMenuItem *result = 0 ;
39443 void *argp1 = 0 ;
39444 int res1 = 0 ;
39445 int val2 ;
39446 int ecode2 = 0 ;
39447 bool temp3 = false ;
39448 bool temp4 = false ;
39449 int val5 ;
39450 int ecode5 = 0 ;
39451 PyObject * obj0 = 0 ;
39452 PyObject * obj1 = 0 ;
39453 PyObject * obj2 = 0 ;
39454 PyObject * obj3 = 0 ;
39455 PyObject * obj4 = 0 ;
39456 char * kwnames[] = {
39457 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39458 };
39459
39460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39462 if (!SWIG_IsOK(res1)) {
39463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39464 }
39465 arg1 = reinterpret_cast< wxMenu * >(argp1);
39466 ecode2 = SWIG_AsVal_int(obj1, &val2);
39467 if (!SWIG_IsOK(ecode2)) {
39468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39469 }
39470 arg2 = static_cast< int >(val2);
39471 if (obj2) {
39472 {
39473 arg3 = wxString_in_helper(obj2);
39474 if (arg3 == NULL) SWIG_fail;
39475 temp3 = true;
39476 }
39477 }
39478 if (obj3) {
39479 {
39480 arg4 = wxString_in_helper(obj3);
39481 if (arg4 == NULL) SWIG_fail;
39482 temp4 = true;
39483 }
39484 }
39485 if (obj4) {
39486 ecode5 = SWIG_AsVal_int(obj4, &val5);
39487 if (!SWIG_IsOK(ecode5)) {
39488 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39489 }
39490 arg5 = static_cast< wxItemKind >(val5);
39491 }
39492 {
39493 PyThreadState* __tstate = wxPyBeginAllowThreads();
39494 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39495 wxPyEndAllowThreads(__tstate);
39496 if (PyErr_Occurred()) SWIG_fail;
39497 }
39498 {
39499 resultobj = wxPyMake_wxObject(result, (bool)0);
39500 }
39501 {
39502 if (temp3)
39503 delete arg3;
39504 }
39505 {
39506 if (temp4)
39507 delete arg4;
39508 }
39509 return resultobj;
39510 fail:
39511 {
39512 if (temp3)
39513 delete arg3;
39514 }
39515 {
39516 if (temp4)
39517 delete arg4;
39518 }
39519 return NULL;
39520 }
39521
39522
39523 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39524 PyObject *resultobj = 0;
39525 wxMenu *arg1 = (wxMenu *) 0 ;
39526 wxMenuItem *result = 0 ;
39527 void *argp1 = 0 ;
39528 int res1 = 0 ;
39529 PyObject *swig_obj[1] ;
39530
39531 if (!args) SWIG_fail;
39532 swig_obj[0] = args;
39533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39534 if (!SWIG_IsOK(res1)) {
39535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39536 }
39537 arg1 = reinterpret_cast< wxMenu * >(argp1);
39538 {
39539 PyThreadState* __tstate = wxPyBeginAllowThreads();
39540 result = (wxMenuItem *)(arg1)->AppendSeparator();
39541 wxPyEndAllowThreads(__tstate);
39542 if (PyErr_Occurred()) SWIG_fail;
39543 }
39544 {
39545 resultobj = wxPyMake_wxObject(result, (bool)0);
39546 }
39547 return resultobj;
39548 fail:
39549 return NULL;
39550 }
39551
39552
39553 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39554 PyObject *resultobj = 0;
39555 wxMenu *arg1 = (wxMenu *) 0 ;
39556 int arg2 ;
39557 wxString *arg3 = 0 ;
39558 wxString const &arg4_defvalue = wxPyEmptyString ;
39559 wxString *arg4 = (wxString *) &arg4_defvalue ;
39560 wxMenuItem *result = 0 ;
39561 void *argp1 = 0 ;
39562 int res1 = 0 ;
39563 int val2 ;
39564 int ecode2 = 0 ;
39565 bool temp3 = false ;
39566 bool temp4 = false ;
39567 PyObject * obj0 = 0 ;
39568 PyObject * obj1 = 0 ;
39569 PyObject * obj2 = 0 ;
39570 PyObject * obj3 = 0 ;
39571 char * kwnames[] = {
39572 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39573 };
39574
39575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39577 if (!SWIG_IsOK(res1)) {
39578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39579 }
39580 arg1 = reinterpret_cast< wxMenu * >(argp1);
39581 ecode2 = SWIG_AsVal_int(obj1, &val2);
39582 if (!SWIG_IsOK(ecode2)) {
39583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39584 }
39585 arg2 = static_cast< int >(val2);
39586 {
39587 arg3 = wxString_in_helper(obj2);
39588 if (arg3 == NULL) SWIG_fail;
39589 temp3 = true;
39590 }
39591 if (obj3) {
39592 {
39593 arg4 = wxString_in_helper(obj3);
39594 if (arg4 == NULL) SWIG_fail;
39595 temp4 = true;
39596 }
39597 }
39598 {
39599 PyThreadState* __tstate = wxPyBeginAllowThreads();
39600 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39601 wxPyEndAllowThreads(__tstate);
39602 if (PyErr_Occurred()) SWIG_fail;
39603 }
39604 {
39605 resultobj = wxPyMake_wxObject(result, (bool)0);
39606 }
39607 {
39608 if (temp3)
39609 delete arg3;
39610 }
39611 {
39612 if (temp4)
39613 delete arg4;
39614 }
39615 return resultobj;
39616 fail:
39617 {
39618 if (temp3)
39619 delete arg3;
39620 }
39621 {
39622 if (temp4)
39623 delete arg4;
39624 }
39625 return NULL;
39626 }
39627
39628
39629 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39630 PyObject *resultobj = 0;
39631 wxMenu *arg1 = (wxMenu *) 0 ;
39632 int arg2 ;
39633 wxString *arg3 = 0 ;
39634 wxString const &arg4_defvalue = wxPyEmptyString ;
39635 wxString *arg4 = (wxString *) &arg4_defvalue ;
39636 wxMenuItem *result = 0 ;
39637 void *argp1 = 0 ;
39638 int res1 = 0 ;
39639 int val2 ;
39640 int ecode2 = 0 ;
39641 bool temp3 = false ;
39642 bool temp4 = false ;
39643 PyObject * obj0 = 0 ;
39644 PyObject * obj1 = 0 ;
39645 PyObject * obj2 = 0 ;
39646 PyObject * obj3 = 0 ;
39647 char * kwnames[] = {
39648 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39649 };
39650
39651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39653 if (!SWIG_IsOK(res1)) {
39654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39655 }
39656 arg1 = reinterpret_cast< wxMenu * >(argp1);
39657 ecode2 = SWIG_AsVal_int(obj1, &val2);
39658 if (!SWIG_IsOK(ecode2)) {
39659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39660 }
39661 arg2 = static_cast< int >(val2);
39662 {
39663 arg3 = wxString_in_helper(obj2);
39664 if (arg3 == NULL) SWIG_fail;
39665 temp3 = true;
39666 }
39667 if (obj3) {
39668 {
39669 arg4 = wxString_in_helper(obj3);
39670 if (arg4 == NULL) SWIG_fail;
39671 temp4 = true;
39672 }
39673 }
39674 {
39675 PyThreadState* __tstate = wxPyBeginAllowThreads();
39676 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39677 wxPyEndAllowThreads(__tstate);
39678 if (PyErr_Occurred()) SWIG_fail;
39679 }
39680 {
39681 resultobj = wxPyMake_wxObject(result, (bool)0);
39682 }
39683 {
39684 if (temp3)
39685 delete arg3;
39686 }
39687 {
39688 if (temp4)
39689 delete arg4;
39690 }
39691 return resultobj;
39692 fail:
39693 {
39694 if (temp3)
39695 delete arg3;
39696 }
39697 {
39698 if (temp4)
39699 delete arg4;
39700 }
39701 return NULL;
39702 }
39703
39704
39705 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39706 PyObject *resultobj = 0;
39707 wxMenu *arg1 = (wxMenu *) 0 ;
39708 int arg2 ;
39709 wxString *arg3 = 0 ;
39710 wxMenu *arg4 = (wxMenu *) 0 ;
39711 wxString const &arg5_defvalue = wxPyEmptyString ;
39712 wxString *arg5 = (wxString *) &arg5_defvalue ;
39713 wxMenuItem *result = 0 ;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 int val2 ;
39717 int ecode2 = 0 ;
39718 bool temp3 = false ;
39719 void *argp4 = 0 ;
39720 int res4 = 0 ;
39721 bool temp5 = false ;
39722 PyObject * obj0 = 0 ;
39723 PyObject * obj1 = 0 ;
39724 PyObject * obj2 = 0 ;
39725 PyObject * obj3 = 0 ;
39726 PyObject * obj4 = 0 ;
39727 char * kwnames[] = {
39728 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39729 };
39730
39731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39733 if (!SWIG_IsOK(res1)) {
39734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39735 }
39736 arg1 = reinterpret_cast< wxMenu * >(argp1);
39737 ecode2 = SWIG_AsVal_int(obj1, &val2);
39738 if (!SWIG_IsOK(ecode2)) {
39739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39740 }
39741 arg2 = static_cast< int >(val2);
39742 {
39743 arg3 = wxString_in_helper(obj2);
39744 if (arg3 == NULL) SWIG_fail;
39745 temp3 = true;
39746 }
39747 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39748 if (!SWIG_IsOK(res4)) {
39749 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39750 }
39751 arg4 = reinterpret_cast< wxMenu * >(argp4);
39752 if (obj4) {
39753 {
39754 arg5 = wxString_in_helper(obj4);
39755 if (arg5 == NULL) SWIG_fail;
39756 temp5 = true;
39757 }
39758 }
39759 {
39760 PyThreadState* __tstate = wxPyBeginAllowThreads();
39761 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 {
39766 resultobj = wxPyMake_wxObject(result, (bool)0);
39767 }
39768 {
39769 if (temp3)
39770 delete arg3;
39771 }
39772 {
39773 if (temp5)
39774 delete arg5;
39775 }
39776 return resultobj;
39777 fail:
39778 {
39779 if (temp3)
39780 delete arg3;
39781 }
39782 {
39783 if (temp5)
39784 delete arg5;
39785 }
39786 return NULL;
39787 }
39788
39789
39790 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = 0;
39792 wxMenu *arg1 = (wxMenu *) 0 ;
39793 wxMenu *arg2 = (wxMenu *) 0 ;
39794 wxString *arg3 = 0 ;
39795 wxString const &arg4_defvalue = wxPyEmptyString ;
39796 wxString *arg4 = (wxString *) &arg4_defvalue ;
39797 wxMenuItem *result = 0 ;
39798 void *argp1 = 0 ;
39799 int res1 = 0 ;
39800 void *argp2 = 0 ;
39801 int res2 = 0 ;
39802 bool temp3 = false ;
39803 bool temp4 = false ;
39804 PyObject * obj0 = 0 ;
39805 PyObject * obj1 = 0 ;
39806 PyObject * obj2 = 0 ;
39807 PyObject * obj3 = 0 ;
39808 char * kwnames[] = {
39809 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39810 };
39811
39812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39814 if (!SWIG_IsOK(res1)) {
39815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39816 }
39817 arg1 = reinterpret_cast< wxMenu * >(argp1);
39818 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39819 if (!SWIG_IsOK(res2)) {
39820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39821 }
39822 arg2 = reinterpret_cast< wxMenu * >(argp2);
39823 {
39824 arg3 = wxString_in_helper(obj2);
39825 if (arg3 == NULL) SWIG_fail;
39826 temp3 = true;
39827 }
39828 if (obj3) {
39829 {
39830 arg4 = wxString_in_helper(obj3);
39831 if (arg4 == NULL) SWIG_fail;
39832 temp4 = true;
39833 }
39834 }
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 {
39842 resultobj = wxPyMake_wxObject(result, (bool)0);
39843 }
39844 {
39845 if (temp3)
39846 delete arg3;
39847 }
39848 {
39849 if (temp4)
39850 delete arg4;
39851 }
39852 return resultobj;
39853 fail:
39854 {
39855 if (temp3)
39856 delete arg3;
39857 }
39858 {
39859 if (temp4)
39860 delete arg4;
39861 }
39862 return NULL;
39863 }
39864
39865
39866 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39867 PyObject *resultobj = 0;
39868 wxMenu *arg1 = (wxMenu *) 0 ;
39869 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39870 wxMenuItem *result = 0 ;
39871 void *argp1 = 0 ;
39872 int res1 = 0 ;
39873 int res2 = 0 ;
39874 PyObject * obj0 = 0 ;
39875 PyObject * obj1 = 0 ;
39876 char * kwnames[] = {
39877 (char *) "self",(char *) "item", NULL
39878 };
39879
39880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39882 if (!SWIG_IsOK(res1)) {
39883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39884 }
39885 arg1 = reinterpret_cast< wxMenu * >(argp1);
39886 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39887 if (!SWIG_IsOK(res2)) {
39888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39889 }
39890 {
39891 PyThreadState* __tstate = wxPyBeginAllowThreads();
39892 result = (wxMenuItem *)(arg1)->Append(arg2);
39893 wxPyEndAllowThreads(__tstate);
39894 if (PyErr_Occurred()) SWIG_fail;
39895 }
39896 {
39897 resultobj = wxPyMake_wxObject(result, (bool)0);
39898 }
39899 return resultobj;
39900 fail:
39901 return NULL;
39902 }
39903
39904
39905 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39906 PyObject *resultobj = 0;
39907 wxMenu *arg1 = (wxMenu *) 0 ;
39908 size_t arg2 ;
39909 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39910 wxMenuItem *result = 0 ;
39911 void *argp1 = 0 ;
39912 int res1 = 0 ;
39913 size_t val2 ;
39914 int ecode2 = 0 ;
39915 int res3 = 0 ;
39916 PyObject * obj0 = 0 ;
39917 PyObject * obj1 = 0 ;
39918 PyObject * obj2 = 0 ;
39919 char * kwnames[] = {
39920 (char *) "self",(char *) "pos",(char *) "item", NULL
39921 };
39922
39923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39925 if (!SWIG_IsOK(res1)) {
39926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39927 }
39928 arg1 = reinterpret_cast< wxMenu * >(argp1);
39929 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39930 if (!SWIG_IsOK(ecode2)) {
39931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39932 }
39933 arg2 = static_cast< size_t >(val2);
39934 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39935 if (!SWIG_IsOK(res3)) {
39936 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39937 }
39938 {
39939 PyThreadState* __tstate = wxPyBeginAllowThreads();
39940 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39941 wxPyEndAllowThreads(__tstate);
39942 if (PyErr_Occurred()) SWIG_fail;
39943 }
39944 {
39945 resultobj = wxPyMake_wxObject(result, (bool)0);
39946 }
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj = 0;
39955 wxMenu *arg1 = (wxMenu *) 0 ;
39956 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39957 wxMenuItem *result = 0 ;
39958 void *argp1 = 0 ;
39959 int res1 = 0 ;
39960 int res2 = 0 ;
39961 PyObject * obj0 = 0 ;
39962 PyObject * obj1 = 0 ;
39963 char * kwnames[] = {
39964 (char *) "self",(char *) "item", NULL
39965 };
39966
39967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39969 if (!SWIG_IsOK(res1)) {
39970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39971 }
39972 arg1 = reinterpret_cast< wxMenu * >(argp1);
39973 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39974 if (!SWIG_IsOK(res2)) {
39975 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39976 }
39977 {
39978 PyThreadState* __tstate = wxPyBeginAllowThreads();
39979 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39980 wxPyEndAllowThreads(__tstate);
39981 if (PyErr_Occurred()) SWIG_fail;
39982 }
39983 {
39984 resultobj = wxPyMake_wxObject(result, (bool)0);
39985 }
39986 return resultobj;
39987 fail:
39988 return NULL;
39989 }
39990
39991
39992 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39993 PyObject *resultobj = 0;
39994 wxMenu *arg1 = (wxMenu *) 0 ;
39995 void *argp1 = 0 ;
39996 int res1 = 0 ;
39997 PyObject *swig_obj[1] ;
39998
39999 if (!args) SWIG_fail;
40000 swig_obj[0] = args;
40001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40002 if (!SWIG_IsOK(res1)) {
40003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40004 }
40005 arg1 = reinterpret_cast< wxMenu * >(argp1);
40006 {
40007 PyThreadState* __tstate = wxPyBeginAllowThreads();
40008 (arg1)->Break();
40009 wxPyEndAllowThreads(__tstate);
40010 if (PyErr_Occurred()) SWIG_fail;
40011 }
40012 resultobj = SWIG_Py_Void();
40013 return resultobj;
40014 fail:
40015 return NULL;
40016 }
40017
40018
40019 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40020 PyObject *resultobj = 0;
40021 wxMenu *arg1 = (wxMenu *) 0 ;
40022 size_t arg2 ;
40023 int arg3 ;
40024 wxString const &arg4_defvalue = wxPyEmptyString ;
40025 wxString *arg4 = (wxString *) &arg4_defvalue ;
40026 wxString const &arg5_defvalue = wxPyEmptyString ;
40027 wxString *arg5 = (wxString *) &arg5_defvalue ;
40028 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40029 wxMenuItem *result = 0 ;
40030 void *argp1 = 0 ;
40031 int res1 = 0 ;
40032 size_t val2 ;
40033 int ecode2 = 0 ;
40034 int val3 ;
40035 int ecode3 = 0 ;
40036 bool temp4 = false ;
40037 bool temp5 = false ;
40038 int val6 ;
40039 int ecode6 = 0 ;
40040 PyObject * obj0 = 0 ;
40041 PyObject * obj1 = 0 ;
40042 PyObject * obj2 = 0 ;
40043 PyObject * obj3 = 0 ;
40044 PyObject * obj4 = 0 ;
40045 PyObject * obj5 = 0 ;
40046 char * kwnames[] = {
40047 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40048 };
40049
40050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40052 if (!SWIG_IsOK(res1)) {
40053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40054 }
40055 arg1 = reinterpret_cast< wxMenu * >(argp1);
40056 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40057 if (!SWIG_IsOK(ecode2)) {
40058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40059 }
40060 arg2 = static_cast< size_t >(val2);
40061 ecode3 = SWIG_AsVal_int(obj2, &val3);
40062 if (!SWIG_IsOK(ecode3)) {
40063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40064 }
40065 arg3 = static_cast< int >(val3);
40066 if (obj3) {
40067 {
40068 arg4 = wxString_in_helper(obj3);
40069 if (arg4 == NULL) SWIG_fail;
40070 temp4 = true;
40071 }
40072 }
40073 if (obj4) {
40074 {
40075 arg5 = wxString_in_helper(obj4);
40076 if (arg5 == NULL) SWIG_fail;
40077 temp5 = true;
40078 }
40079 }
40080 if (obj5) {
40081 ecode6 = SWIG_AsVal_int(obj5, &val6);
40082 if (!SWIG_IsOK(ecode6)) {
40083 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40084 }
40085 arg6 = static_cast< wxItemKind >(val6);
40086 }
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 {
40094 resultobj = wxPyMake_wxObject(result, (bool)0);
40095 }
40096 {
40097 if (temp4)
40098 delete arg4;
40099 }
40100 {
40101 if (temp5)
40102 delete arg5;
40103 }
40104 return resultobj;
40105 fail:
40106 {
40107 if (temp4)
40108 delete arg4;
40109 }
40110 {
40111 if (temp5)
40112 delete arg5;
40113 }
40114 return NULL;
40115 }
40116
40117
40118 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40119 PyObject *resultobj = 0;
40120 wxMenu *arg1 = (wxMenu *) 0 ;
40121 size_t arg2 ;
40122 wxMenuItem *result = 0 ;
40123 void *argp1 = 0 ;
40124 int res1 = 0 ;
40125 size_t val2 ;
40126 int ecode2 = 0 ;
40127 PyObject * obj0 = 0 ;
40128 PyObject * obj1 = 0 ;
40129 char * kwnames[] = {
40130 (char *) "self",(char *) "pos", NULL
40131 };
40132
40133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40135 if (!SWIG_IsOK(res1)) {
40136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40137 }
40138 arg1 = reinterpret_cast< wxMenu * >(argp1);
40139 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40140 if (!SWIG_IsOK(ecode2)) {
40141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40142 }
40143 arg2 = static_cast< size_t >(val2);
40144 {
40145 PyThreadState* __tstate = wxPyBeginAllowThreads();
40146 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40147 wxPyEndAllowThreads(__tstate);
40148 if (PyErr_Occurred()) SWIG_fail;
40149 }
40150 {
40151 resultobj = wxPyMake_wxObject(result, (bool)0);
40152 }
40153 return resultobj;
40154 fail:
40155 return NULL;
40156 }
40157
40158
40159 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40160 PyObject *resultobj = 0;
40161 wxMenu *arg1 = (wxMenu *) 0 ;
40162 size_t arg2 ;
40163 int arg3 ;
40164 wxString *arg4 = 0 ;
40165 wxString const &arg5_defvalue = wxPyEmptyString ;
40166 wxString *arg5 = (wxString *) &arg5_defvalue ;
40167 wxMenuItem *result = 0 ;
40168 void *argp1 = 0 ;
40169 int res1 = 0 ;
40170 size_t val2 ;
40171 int ecode2 = 0 ;
40172 int val3 ;
40173 int ecode3 = 0 ;
40174 bool temp4 = false ;
40175 bool temp5 = false ;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 PyObject * obj2 = 0 ;
40179 PyObject * obj3 = 0 ;
40180 PyObject * obj4 = 0 ;
40181 char * kwnames[] = {
40182 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40183 };
40184
40185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40187 if (!SWIG_IsOK(res1)) {
40188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40189 }
40190 arg1 = reinterpret_cast< wxMenu * >(argp1);
40191 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40192 if (!SWIG_IsOK(ecode2)) {
40193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40194 }
40195 arg2 = static_cast< size_t >(val2);
40196 ecode3 = SWIG_AsVal_int(obj2, &val3);
40197 if (!SWIG_IsOK(ecode3)) {
40198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40199 }
40200 arg3 = static_cast< int >(val3);
40201 {
40202 arg4 = wxString_in_helper(obj3);
40203 if (arg4 == NULL) SWIG_fail;
40204 temp4 = true;
40205 }
40206 if (obj4) {
40207 {
40208 arg5 = wxString_in_helper(obj4);
40209 if (arg5 == NULL) SWIG_fail;
40210 temp5 = true;
40211 }
40212 }
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40216 wxPyEndAllowThreads(__tstate);
40217 if (PyErr_Occurred()) SWIG_fail;
40218 }
40219 {
40220 resultobj = wxPyMake_wxObject(result, (bool)0);
40221 }
40222 {
40223 if (temp4)
40224 delete arg4;
40225 }
40226 {
40227 if (temp5)
40228 delete arg5;
40229 }
40230 return resultobj;
40231 fail:
40232 {
40233 if (temp4)
40234 delete arg4;
40235 }
40236 {
40237 if (temp5)
40238 delete arg5;
40239 }
40240 return NULL;
40241 }
40242
40243
40244 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40245 PyObject *resultobj = 0;
40246 wxMenu *arg1 = (wxMenu *) 0 ;
40247 size_t arg2 ;
40248 int arg3 ;
40249 wxString *arg4 = 0 ;
40250 wxString const &arg5_defvalue = wxPyEmptyString ;
40251 wxString *arg5 = (wxString *) &arg5_defvalue ;
40252 wxMenuItem *result = 0 ;
40253 void *argp1 = 0 ;
40254 int res1 = 0 ;
40255 size_t val2 ;
40256 int ecode2 = 0 ;
40257 int val3 ;
40258 int ecode3 = 0 ;
40259 bool temp4 = false ;
40260 bool temp5 = false ;
40261 PyObject * obj0 = 0 ;
40262 PyObject * obj1 = 0 ;
40263 PyObject * obj2 = 0 ;
40264 PyObject * obj3 = 0 ;
40265 PyObject * obj4 = 0 ;
40266 char * kwnames[] = {
40267 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40268 };
40269
40270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40272 if (!SWIG_IsOK(res1)) {
40273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40274 }
40275 arg1 = reinterpret_cast< wxMenu * >(argp1);
40276 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40277 if (!SWIG_IsOK(ecode2)) {
40278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40279 }
40280 arg2 = static_cast< size_t >(val2);
40281 ecode3 = SWIG_AsVal_int(obj2, &val3);
40282 if (!SWIG_IsOK(ecode3)) {
40283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40284 }
40285 arg3 = static_cast< int >(val3);
40286 {
40287 arg4 = wxString_in_helper(obj3);
40288 if (arg4 == NULL) SWIG_fail;
40289 temp4 = true;
40290 }
40291 if (obj4) {
40292 {
40293 arg5 = wxString_in_helper(obj4);
40294 if (arg5 == NULL) SWIG_fail;
40295 temp5 = true;
40296 }
40297 }
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40301 wxPyEndAllowThreads(__tstate);
40302 if (PyErr_Occurred()) SWIG_fail;
40303 }
40304 {
40305 resultobj = wxPyMake_wxObject(result, (bool)0);
40306 }
40307 {
40308 if (temp4)
40309 delete arg4;
40310 }
40311 {
40312 if (temp5)
40313 delete arg5;
40314 }
40315 return resultobj;
40316 fail:
40317 {
40318 if (temp4)
40319 delete arg4;
40320 }
40321 {
40322 if (temp5)
40323 delete arg5;
40324 }
40325 return NULL;
40326 }
40327
40328
40329 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40330 PyObject *resultobj = 0;
40331 wxMenu *arg1 = (wxMenu *) 0 ;
40332 size_t arg2 ;
40333 int arg3 ;
40334 wxString *arg4 = 0 ;
40335 wxMenu *arg5 = (wxMenu *) 0 ;
40336 wxString const &arg6_defvalue = wxPyEmptyString ;
40337 wxString *arg6 = (wxString *) &arg6_defvalue ;
40338 wxMenuItem *result = 0 ;
40339 void *argp1 = 0 ;
40340 int res1 = 0 ;
40341 size_t val2 ;
40342 int ecode2 = 0 ;
40343 int val3 ;
40344 int ecode3 = 0 ;
40345 bool temp4 = false ;
40346 void *argp5 = 0 ;
40347 int res5 = 0 ;
40348 bool temp6 = false ;
40349 PyObject * obj0 = 0 ;
40350 PyObject * obj1 = 0 ;
40351 PyObject * obj2 = 0 ;
40352 PyObject * obj3 = 0 ;
40353 PyObject * obj4 = 0 ;
40354 PyObject * obj5 = 0 ;
40355 char * kwnames[] = {
40356 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40357 };
40358
40359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40361 if (!SWIG_IsOK(res1)) {
40362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40363 }
40364 arg1 = reinterpret_cast< wxMenu * >(argp1);
40365 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40366 if (!SWIG_IsOK(ecode2)) {
40367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40368 }
40369 arg2 = static_cast< size_t >(val2);
40370 ecode3 = SWIG_AsVal_int(obj2, &val3);
40371 if (!SWIG_IsOK(ecode3)) {
40372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40373 }
40374 arg3 = static_cast< int >(val3);
40375 {
40376 arg4 = wxString_in_helper(obj3);
40377 if (arg4 == NULL) SWIG_fail;
40378 temp4 = true;
40379 }
40380 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res5)) {
40382 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40383 }
40384 arg5 = reinterpret_cast< wxMenu * >(argp5);
40385 if (obj5) {
40386 {
40387 arg6 = wxString_in_helper(obj5);
40388 if (arg6 == NULL) SWIG_fail;
40389 temp6 = true;
40390 }
40391 }
40392 {
40393 PyThreadState* __tstate = wxPyBeginAllowThreads();
40394 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40395 wxPyEndAllowThreads(__tstate);
40396 if (PyErr_Occurred()) SWIG_fail;
40397 }
40398 {
40399 resultobj = wxPyMake_wxObject(result, (bool)0);
40400 }
40401 {
40402 if (temp4)
40403 delete arg4;
40404 }
40405 {
40406 if (temp6)
40407 delete arg6;
40408 }
40409 return resultobj;
40410 fail:
40411 {
40412 if (temp4)
40413 delete arg4;
40414 }
40415 {
40416 if (temp6)
40417 delete arg6;
40418 }
40419 return NULL;
40420 }
40421
40422
40423 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40424 PyObject *resultobj = 0;
40425 wxMenu *arg1 = (wxMenu *) 0 ;
40426 int arg2 ;
40427 wxString const &arg3_defvalue = wxPyEmptyString ;
40428 wxString *arg3 = (wxString *) &arg3_defvalue ;
40429 wxString const &arg4_defvalue = wxPyEmptyString ;
40430 wxString *arg4 = (wxString *) &arg4_defvalue ;
40431 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40432 wxMenuItem *result = 0 ;
40433 void *argp1 = 0 ;
40434 int res1 = 0 ;
40435 int val2 ;
40436 int ecode2 = 0 ;
40437 bool temp3 = false ;
40438 bool temp4 = false ;
40439 int val5 ;
40440 int ecode5 = 0 ;
40441 PyObject * obj0 = 0 ;
40442 PyObject * obj1 = 0 ;
40443 PyObject * obj2 = 0 ;
40444 PyObject * obj3 = 0 ;
40445 PyObject * obj4 = 0 ;
40446 char * kwnames[] = {
40447 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40448 };
40449
40450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40452 if (!SWIG_IsOK(res1)) {
40453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40454 }
40455 arg1 = reinterpret_cast< wxMenu * >(argp1);
40456 ecode2 = SWIG_AsVal_int(obj1, &val2);
40457 if (!SWIG_IsOK(ecode2)) {
40458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40459 }
40460 arg2 = static_cast< int >(val2);
40461 if (obj2) {
40462 {
40463 arg3 = wxString_in_helper(obj2);
40464 if (arg3 == NULL) SWIG_fail;
40465 temp3 = true;
40466 }
40467 }
40468 if (obj3) {
40469 {
40470 arg4 = wxString_in_helper(obj3);
40471 if (arg4 == NULL) SWIG_fail;
40472 temp4 = true;
40473 }
40474 }
40475 if (obj4) {
40476 ecode5 = SWIG_AsVal_int(obj4, &val5);
40477 if (!SWIG_IsOK(ecode5)) {
40478 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40479 }
40480 arg5 = static_cast< wxItemKind >(val5);
40481 }
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 {
40489 resultobj = wxPyMake_wxObject(result, (bool)0);
40490 }
40491 {
40492 if (temp3)
40493 delete arg3;
40494 }
40495 {
40496 if (temp4)
40497 delete arg4;
40498 }
40499 return resultobj;
40500 fail:
40501 {
40502 if (temp3)
40503 delete arg3;
40504 }
40505 {
40506 if (temp4)
40507 delete arg4;
40508 }
40509 return NULL;
40510 }
40511
40512
40513 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40514 PyObject *resultobj = 0;
40515 wxMenu *arg1 = (wxMenu *) 0 ;
40516 wxMenuItem *result = 0 ;
40517 void *argp1 = 0 ;
40518 int res1 = 0 ;
40519 PyObject *swig_obj[1] ;
40520
40521 if (!args) SWIG_fail;
40522 swig_obj[0] = args;
40523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40524 if (!SWIG_IsOK(res1)) {
40525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40526 }
40527 arg1 = reinterpret_cast< wxMenu * >(argp1);
40528 {
40529 PyThreadState* __tstate = wxPyBeginAllowThreads();
40530 result = (wxMenuItem *)(arg1)->PrependSeparator();
40531 wxPyEndAllowThreads(__tstate);
40532 if (PyErr_Occurred()) SWIG_fail;
40533 }
40534 {
40535 resultobj = wxPyMake_wxObject(result, (bool)0);
40536 }
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40544 PyObject *resultobj = 0;
40545 wxMenu *arg1 = (wxMenu *) 0 ;
40546 int arg2 ;
40547 wxString *arg3 = 0 ;
40548 wxString const &arg4_defvalue = wxPyEmptyString ;
40549 wxString *arg4 = (wxString *) &arg4_defvalue ;
40550 wxMenuItem *result = 0 ;
40551 void *argp1 = 0 ;
40552 int res1 = 0 ;
40553 int val2 ;
40554 int ecode2 = 0 ;
40555 bool temp3 = false ;
40556 bool temp4 = false ;
40557 PyObject * obj0 = 0 ;
40558 PyObject * obj1 = 0 ;
40559 PyObject * obj2 = 0 ;
40560 PyObject * obj3 = 0 ;
40561 char * kwnames[] = {
40562 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40563 };
40564
40565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40567 if (!SWIG_IsOK(res1)) {
40568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40569 }
40570 arg1 = reinterpret_cast< wxMenu * >(argp1);
40571 ecode2 = SWIG_AsVal_int(obj1, &val2);
40572 if (!SWIG_IsOK(ecode2)) {
40573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40574 }
40575 arg2 = static_cast< int >(val2);
40576 {
40577 arg3 = wxString_in_helper(obj2);
40578 if (arg3 == NULL) SWIG_fail;
40579 temp3 = true;
40580 }
40581 if (obj3) {
40582 {
40583 arg4 = wxString_in_helper(obj3);
40584 if (arg4 == NULL) SWIG_fail;
40585 temp4 = true;
40586 }
40587 }
40588 {
40589 PyThreadState* __tstate = wxPyBeginAllowThreads();
40590 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40591 wxPyEndAllowThreads(__tstate);
40592 if (PyErr_Occurred()) SWIG_fail;
40593 }
40594 {
40595 resultobj = wxPyMake_wxObject(result, (bool)0);
40596 }
40597 {
40598 if (temp3)
40599 delete arg3;
40600 }
40601 {
40602 if (temp4)
40603 delete arg4;
40604 }
40605 return resultobj;
40606 fail:
40607 {
40608 if (temp3)
40609 delete arg3;
40610 }
40611 {
40612 if (temp4)
40613 delete arg4;
40614 }
40615 return NULL;
40616 }
40617
40618
40619 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40620 PyObject *resultobj = 0;
40621 wxMenu *arg1 = (wxMenu *) 0 ;
40622 int arg2 ;
40623 wxString *arg3 = 0 ;
40624 wxString const &arg4_defvalue = wxPyEmptyString ;
40625 wxString *arg4 = (wxString *) &arg4_defvalue ;
40626 wxMenuItem *result = 0 ;
40627 void *argp1 = 0 ;
40628 int res1 = 0 ;
40629 int val2 ;
40630 int ecode2 = 0 ;
40631 bool temp3 = false ;
40632 bool temp4 = false ;
40633 PyObject * obj0 = 0 ;
40634 PyObject * obj1 = 0 ;
40635 PyObject * obj2 = 0 ;
40636 PyObject * obj3 = 0 ;
40637 char * kwnames[] = {
40638 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40639 };
40640
40641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40643 if (!SWIG_IsOK(res1)) {
40644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40645 }
40646 arg1 = reinterpret_cast< wxMenu * >(argp1);
40647 ecode2 = SWIG_AsVal_int(obj1, &val2);
40648 if (!SWIG_IsOK(ecode2)) {
40649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40650 }
40651 arg2 = static_cast< int >(val2);
40652 {
40653 arg3 = wxString_in_helper(obj2);
40654 if (arg3 == NULL) SWIG_fail;
40655 temp3 = true;
40656 }
40657 if (obj3) {
40658 {
40659 arg4 = wxString_in_helper(obj3);
40660 if (arg4 == NULL) SWIG_fail;
40661 temp4 = true;
40662 }
40663 }
40664 {
40665 PyThreadState* __tstate = wxPyBeginAllowThreads();
40666 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40667 wxPyEndAllowThreads(__tstate);
40668 if (PyErr_Occurred()) SWIG_fail;
40669 }
40670 {
40671 resultobj = wxPyMake_wxObject(result, (bool)0);
40672 }
40673 {
40674 if (temp3)
40675 delete arg3;
40676 }
40677 {
40678 if (temp4)
40679 delete arg4;
40680 }
40681 return resultobj;
40682 fail:
40683 {
40684 if (temp3)
40685 delete arg3;
40686 }
40687 {
40688 if (temp4)
40689 delete arg4;
40690 }
40691 return NULL;
40692 }
40693
40694
40695 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40696 PyObject *resultobj = 0;
40697 wxMenu *arg1 = (wxMenu *) 0 ;
40698 int arg2 ;
40699 wxString *arg3 = 0 ;
40700 wxMenu *arg4 = (wxMenu *) 0 ;
40701 wxString const &arg5_defvalue = wxPyEmptyString ;
40702 wxString *arg5 = (wxString *) &arg5_defvalue ;
40703 wxMenuItem *result = 0 ;
40704 void *argp1 = 0 ;
40705 int res1 = 0 ;
40706 int val2 ;
40707 int ecode2 = 0 ;
40708 bool temp3 = false ;
40709 void *argp4 = 0 ;
40710 int res4 = 0 ;
40711 bool temp5 = false ;
40712 PyObject * obj0 = 0 ;
40713 PyObject * obj1 = 0 ;
40714 PyObject * obj2 = 0 ;
40715 PyObject * obj3 = 0 ;
40716 PyObject * obj4 = 0 ;
40717 char * kwnames[] = {
40718 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40719 };
40720
40721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40723 if (!SWIG_IsOK(res1)) {
40724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40725 }
40726 arg1 = reinterpret_cast< wxMenu * >(argp1);
40727 ecode2 = SWIG_AsVal_int(obj1, &val2);
40728 if (!SWIG_IsOK(ecode2)) {
40729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40730 }
40731 arg2 = static_cast< int >(val2);
40732 {
40733 arg3 = wxString_in_helper(obj2);
40734 if (arg3 == NULL) SWIG_fail;
40735 temp3 = true;
40736 }
40737 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40738 if (!SWIG_IsOK(res4)) {
40739 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40740 }
40741 arg4 = reinterpret_cast< wxMenu * >(argp4);
40742 if (obj4) {
40743 {
40744 arg5 = wxString_in_helper(obj4);
40745 if (arg5 == NULL) SWIG_fail;
40746 temp5 = true;
40747 }
40748 }
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40752 wxPyEndAllowThreads(__tstate);
40753 if (PyErr_Occurred()) SWIG_fail;
40754 }
40755 {
40756 resultobj = wxPyMake_wxObject(result, (bool)0);
40757 }
40758 {
40759 if (temp3)
40760 delete arg3;
40761 }
40762 {
40763 if (temp5)
40764 delete arg5;
40765 }
40766 return resultobj;
40767 fail:
40768 {
40769 if (temp3)
40770 delete arg3;
40771 }
40772 {
40773 if (temp5)
40774 delete arg5;
40775 }
40776 return NULL;
40777 }
40778
40779
40780 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40781 PyObject *resultobj = 0;
40782 wxMenu *arg1 = (wxMenu *) 0 ;
40783 int arg2 ;
40784 wxMenuItem *result = 0 ;
40785 void *argp1 = 0 ;
40786 int res1 = 0 ;
40787 int val2 ;
40788 int ecode2 = 0 ;
40789 PyObject * obj0 = 0 ;
40790 PyObject * obj1 = 0 ;
40791 char * kwnames[] = {
40792 (char *) "self",(char *) "id", NULL
40793 };
40794
40795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40797 if (!SWIG_IsOK(res1)) {
40798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40799 }
40800 arg1 = reinterpret_cast< wxMenu * >(argp1);
40801 ecode2 = SWIG_AsVal_int(obj1, &val2);
40802 if (!SWIG_IsOK(ecode2)) {
40803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40804 }
40805 arg2 = static_cast< int >(val2);
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 result = (wxMenuItem *)(arg1)->Remove(arg2);
40809 wxPyEndAllowThreads(__tstate);
40810 if (PyErr_Occurred()) SWIG_fail;
40811 }
40812 {
40813 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40814 }
40815 return resultobj;
40816 fail:
40817 return NULL;
40818 }
40819
40820
40821 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj = 0;
40823 wxMenu *arg1 = (wxMenu *) 0 ;
40824 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40825 wxMenuItem *result = 0 ;
40826 void *argp1 = 0 ;
40827 int res1 = 0 ;
40828 void *argp2 = 0 ;
40829 int res2 = 0 ;
40830 PyObject * obj0 = 0 ;
40831 PyObject * obj1 = 0 ;
40832 char * kwnames[] = {
40833 (char *) "self",(char *) "item", NULL
40834 };
40835
40836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40838 if (!SWIG_IsOK(res1)) {
40839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40840 }
40841 arg1 = reinterpret_cast< wxMenu * >(argp1);
40842 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40843 if (!SWIG_IsOK(res2)) {
40844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40845 }
40846 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40847 {
40848 PyThreadState* __tstate = wxPyBeginAllowThreads();
40849 result = (wxMenuItem *)(arg1)->Remove(arg2);
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 {
40854 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40855 }
40856 return resultobj;
40857 fail:
40858 return NULL;
40859 }
40860
40861
40862 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40863 PyObject *resultobj = 0;
40864 wxMenu *arg1 = (wxMenu *) 0 ;
40865 int arg2 ;
40866 bool result;
40867 void *argp1 = 0 ;
40868 int res1 = 0 ;
40869 int val2 ;
40870 int ecode2 = 0 ;
40871 PyObject * obj0 = 0 ;
40872 PyObject * obj1 = 0 ;
40873 char * kwnames[] = {
40874 (char *) "self",(char *) "id", NULL
40875 };
40876
40877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40879 if (!SWIG_IsOK(res1)) {
40880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40881 }
40882 arg1 = reinterpret_cast< wxMenu * >(argp1);
40883 ecode2 = SWIG_AsVal_int(obj1, &val2);
40884 if (!SWIG_IsOK(ecode2)) {
40885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40886 }
40887 arg2 = static_cast< int >(val2);
40888 {
40889 PyThreadState* __tstate = wxPyBeginAllowThreads();
40890 result = (bool)(arg1)->Delete(arg2);
40891 wxPyEndAllowThreads(__tstate);
40892 if (PyErr_Occurred()) SWIG_fail;
40893 }
40894 {
40895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40896 }
40897 return resultobj;
40898 fail:
40899 return NULL;
40900 }
40901
40902
40903 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40904 PyObject *resultobj = 0;
40905 wxMenu *arg1 = (wxMenu *) 0 ;
40906 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40907 bool result;
40908 void *argp1 = 0 ;
40909 int res1 = 0 ;
40910 void *argp2 = 0 ;
40911 int res2 = 0 ;
40912 PyObject * obj0 = 0 ;
40913 PyObject * obj1 = 0 ;
40914 char * kwnames[] = {
40915 (char *) "self",(char *) "item", NULL
40916 };
40917
40918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40920 if (!SWIG_IsOK(res1)) {
40921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40922 }
40923 arg1 = reinterpret_cast< wxMenu * >(argp1);
40924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40925 if (!SWIG_IsOK(res2)) {
40926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40927 }
40928 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40929 {
40930 PyThreadState* __tstate = wxPyBeginAllowThreads();
40931 result = (bool)(arg1)->Delete(arg2);
40932 wxPyEndAllowThreads(__tstate);
40933 if (PyErr_Occurred()) SWIG_fail;
40934 }
40935 {
40936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40937 }
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40945 PyObject *resultobj = 0;
40946 wxMenu *arg1 = (wxMenu *) 0 ;
40947 void *argp1 = 0 ;
40948 int res1 = 0 ;
40949 PyObject *swig_obj[1] ;
40950
40951 if (!args) SWIG_fail;
40952 swig_obj[0] = args;
40953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40954 if (!SWIG_IsOK(res1)) {
40955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40956 }
40957 arg1 = reinterpret_cast< wxMenu * >(argp1);
40958 {
40959 PyThreadState* __tstate = wxPyBeginAllowThreads();
40960 wxMenu_Destroy(arg1);
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 resultobj = SWIG_Py_Void();
40965 return resultobj;
40966 fail:
40967 return NULL;
40968 }
40969
40970
40971 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj = 0;
40973 wxMenu *arg1 = (wxMenu *) 0 ;
40974 int arg2 ;
40975 bool result;
40976 void *argp1 = 0 ;
40977 int res1 = 0 ;
40978 int val2 ;
40979 int ecode2 = 0 ;
40980 PyObject * obj0 = 0 ;
40981 PyObject * obj1 = 0 ;
40982 char * kwnames[] = {
40983 (char *) "self",(char *) "id", NULL
40984 };
40985
40986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40988 if (!SWIG_IsOK(res1)) {
40989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40990 }
40991 arg1 = reinterpret_cast< wxMenu * >(argp1);
40992 ecode2 = SWIG_AsVal_int(obj1, &val2);
40993 if (!SWIG_IsOK(ecode2)) {
40994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40995 }
40996 arg2 = static_cast< int >(val2);
40997 {
40998 PyThreadState* __tstate = wxPyBeginAllowThreads();
40999 result = (bool)(arg1)->Destroy(arg2);
41000 wxPyEndAllowThreads(__tstate);
41001 if (PyErr_Occurred()) SWIG_fail;
41002 }
41003 {
41004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41005 }
41006 return resultobj;
41007 fail:
41008 return NULL;
41009 }
41010
41011
41012 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41013 PyObject *resultobj = 0;
41014 wxMenu *arg1 = (wxMenu *) 0 ;
41015 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41016 bool result;
41017 void *argp1 = 0 ;
41018 int res1 = 0 ;
41019 void *argp2 = 0 ;
41020 int res2 = 0 ;
41021 PyObject * obj0 = 0 ;
41022 PyObject * obj1 = 0 ;
41023 char * kwnames[] = {
41024 (char *) "self",(char *) "item", NULL
41025 };
41026
41027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41029 if (!SWIG_IsOK(res1)) {
41030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41031 }
41032 arg1 = reinterpret_cast< wxMenu * >(argp1);
41033 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41034 if (!SWIG_IsOK(res2)) {
41035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41036 }
41037 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41038 {
41039 PyThreadState* __tstate = wxPyBeginAllowThreads();
41040 result = (bool)(arg1)->Destroy(arg2);
41041 wxPyEndAllowThreads(__tstate);
41042 if (PyErr_Occurred()) SWIG_fail;
41043 }
41044 {
41045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41046 }
41047 return resultobj;
41048 fail:
41049 return NULL;
41050 }
41051
41052
41053 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41054 PyObject *resultobj = 0;
41055 wxMenu *arg1 = (wxMenu *) 0 ;
41056 size_t result;
41057 void *argp1 = 0 ;
41058 int res1 = 0 ;
41059 PyObject *swig_obj[1] ;
41060
41061 if (!args) SWIG_fail;
41062 swig_obj[0] = args;
41063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41064 if (!SWIG_IsOK(res1)) {
41065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41066 }
41067 arg1 = reinterpret_cast< wxMenu * >(argp1);
41068 {
41069 PyThreadState* __tstate = wxPyBeginAllowThreads();
41070 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41075 return resultobj;
41076 fail:
41077 return NULL;
41078 }
41079
41080
41081 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41082 PyObject *resultobj = 0;
41083 wxMenu *arg1 = (wxMenu *) 0 ;
41084 PyObject *result = 0 ;
41085 void *argp1 = 0 ;
41086 int res1 = 0 ;
41087 PyObject *swig_obj[1] ;
41088
41089 if (!args) SWIG_fail;
41090 swig_obj[0] = args;
41091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41092 if (!SWIG_IsOK(res1)) {
41093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41094 }
41095 arg1 = reinterpret_cast< wxMenu * >(argp1);
41096 {
41097 PyThreadState* __tstate = wxPyBeginAllowThreads();
41098 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 resultobj = result;
41103 return resultobj;
41104 fail:
41105 return NULL;
41106 }
41107
41108
41109 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41110 PyObject *resultobj = 0;
41111 wxMenu *arg1 = (wxMenu *) 0 ;
41112 wxString *arg2 = 0 ;
41113 int result;
41114 void *argp1 = 0 ;
41115 int res1 = 0 ;
41116 bool temp2 = false ;
41117 PyObject * obj0 = 0 ;
41118 PyObject * obj1 = 0 ;
41119 char * kwnames[] = {
41120 (char *) "self",(char *) "item", NULL
41121 };
41122
41123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41125 if (!SWIG_IsOK(res1)) {
41126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41127 }
41128 arg1 = reinterpret_cast< wxMenu * >(argp1);
41129 {
41130 arg2 = wxString_in_helper(obj1);
41131 if (arg2 == NULL) SWIG_fail;
41132 temp2 = true;
41133 }
41134 {
41135 PyThreadState* __tstate = wxPyBeginAllowThreads();
41136 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41137 wxPyEndAllowThreads(__tstate);
41138 if (PyErr_Occurred()) SWIG_fail;
41139 }
41140 resultobj = SWIG_From_int(static_cast< int >(result));
41141 {
41142 if (temp2)
41143 delete arg2;
41144 }
41145 return resultobj;
41146 fail:
41147 {
41148 if (temp2)
41149 delete arg2;
41150 }
41151 return NULL;
41152 }
41153
41154
41155 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41156 PyObject *resultobj = 0;
41157 wxMenu *arg1 = (wxMenu *) 0 ;
41158 int arg2 ;
41159 wxMenuItem *result = 0 ;
41160 void *argp1 = 0 ;
41161 int res1 = 0 ;
41162 int val2 ;
41163 int ecode2 = 0 ;
41164 PyObject * obj0 = 0 ;
41165 PyObject * obj1 = 0 ;
41166 char * kwnames[] = {
41167 (char *) "self",(char *) "id", NULL
41168 };
41169
41170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41172 if (!SWIG_IsOK(res1)) {
41173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41174 }
41175 arg1 = reinterpret_cast< wxMenu * >(argp1);
41176 ecode2 = SWIG_AsVal_int(obj1, &val2);
41177 if (!SWIG_IsOK(ecode2)) {
41178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41179 }
41180 arg2 = static_cast< int >(val2);
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41184 wxPyEndAllowThreads(__tstate);
41185 if (PyErr_Occurred()) SWIG_fail;
41186 }
41187 {
41188 resultobj = wxPyMake_wxObject(result, (bool)0);
41189 }
41190 return resultobj;
41191 fail:
41192 return NULL;
41193 }
41194
41195
41196 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41197 PyObject *resultobj = 0;
41198 wxMenu *arg1 = (wxMenu *) 0 ;
41199 size_t arg2 ;
41200 wxMenuItem *result = 0 ;
41201 void *argp1 = 0 ;
41202 int res1 = 0 ;
41203 size_t val2 ;
41204 int ecode2 = 0 ;
41205 PyObject * obj0 = 0 ;
41206 PyObject * obj1 = 0 ;
41207 char * kwnames[] = {
41208 (char *) "self",(char *) "position", NULL
41209 };
41210
41211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41213 if (!SWIG_IsOK(res1)) {
41214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41215 }
41216 arg1 = reinterpret_cast< wxMenu * >(argp1);
41217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41218 if (!SWIG_IsOK(ecode2)) {
41219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41220 }
41221 arg2 = static_cast< size_t >(val2);
41222 {
41223 PyThreadState* __tstate = wxPyBeginAllowThreads();
41224 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41225 wxPyEndAllowThreads(__tstate);
41226 if (PyErr_Occurred()) SWIG_fail;
41227 }
41228 {
41229 resultobj = wxPyMake_wxObject(result, (bool)0);
41230 }
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = 0;
41239 wxMenu *arg1 = (wxMenu *) 0 ;
41240 int arg2 ;
41241 bool arg3 ;
41242 void *argp1 = 0 ;
41243 int res1 = 0 ;
41244 int val2 ;
41245 int ecode2 = 0 ;
41246 bool val3 ;
41247 int ecode3 = 0 ;
41248 PyObject * obj0 = 0 ;
41249 PyObject * obj1 = 0 ;
41250 PyObject * obj2 = 0 ;
41251 char * kwnames[] = {
41252 (char *) "self",(char *) "id",(char *) "enable", NULL
41253 };
41254
41255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41257 if (!SWIG_IsOK(res1)) {
41258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41259 }
41260 arg1 = reinterpret_cast< wxMenu * >(argp1);
41261 ecode2 = SWIG_AsVal_int(obj1, &val2);
41262 if (!SWIG_IsOK(ecode2)) {
41263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41264 }
41265 arg2 = static_cast< int >(val2);
41266 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41267 if (!SWIG_IsOK(ecode3)) {
41268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41269 }
41270 arg3 = static_cast< bool >(val3);
41271 {
41272 PyThreadState* __tstate = wxPyBeginAllowThreads();
41273 (arg1)->Enable(arg2,arg3);
41274 wxPyEndAllowThreads(__tstate);
41275 if (PyErr_Occurred()) SWIG_fail;
41276 }
41277 resultobj = SWIG_Py_Void();
41278 return resultobj;
41279 fail:
41280 return NULL;
41281 }
41282
41283
41284 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj = 0;
41286 wxMenu *arg1 = (wxMenu *) 0 ;
41287 int arg2 ;
41288 bool result;
41289 void *argp1 = 0 ;
41290 int res1 = 0 ;
41291 int val2 ;
41292 int ecode2 = 0 ;
41293 PyObject * obj0 = 0 ;
41294 PyObject * obj1 = 0 ;
41295 char * kwnames[] = {
41296 (char *) "self",(char *) "id", NULL
41297 };
41298
41299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41301 if (!SWIG_IsOK(res1)) {
41302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41303 }
41304 arg1 = reinterpret_cast< wxMenu * >(argp1);
41305 ecode2 = SWIG_AsVal_int(obj1, &val2);
41306 if (!SWIG_IsOK(ecode2)) {
41307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41308 }
41309 arg2 = static_cast< int >(val2);
41310 {
41311 PyThreadState* __tstate = wxPyBeginAllowThreads();
41312 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41313 wxPyEndAllowThreads(__tstate);
41314 if (PyErr_Occurred()) SWIG_fail;
41315 }
41316 {
41317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41318 }
41319 return resultobj;
41320 fail:
41321 return NULL;
41322 }
41323
41324
41325 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41326 PyObject *resultobj = 0;
41327 wxMenu *arg1 = (wxMenu *) 0 ;
41328 int arg2 ;
41329 bool arg3 ;
41330 void *argp1 = 0 ;
41331 int res1 = 0 ;
41332 int val2 ;
41333 int ecode2 = 0 ;
41334 bool val3 ;
41335 int ecode3 = 0 ;
41336 PyObject * obj0 = 0 ;
41337 PyObject * obj1 = 0 ;
41338 PyObject * obj2 = 0 ;
41339 char * kwnames[] = {
41340 (char *) "self",(char *) "id",(char *) "check", NULL
41341 };
41342
41343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41345 if (!SWIG_IsOK(res1)) {
41346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41347 }
41348 arg1 = reinterpret_cast< wxMenu * >(argp1);
41349 ecode2 = SWIG_AsVal_int(obj1, &val2);
41350 if (!SWIG_IsOK(ecode2)) {
41351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41352 }
41353 arg2 = static_cast< int >(val2);
41354 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41355 if (!SWIG_IsOK(ecode3)) {
41356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41357 }
41358 arg3 = static_cast< bool >(val3);
41359 {
41360 PyThreadState* __tstate = wxPyBeginAllowThreads();
41361 (arg1)->Check(arg2,arg3);
41362 wxPyEndAllowThreads(__tstate);
41363 if (PyErr_Occurred()) SWIG_fail;
41364 }
41365 resultobj = SWIG_Py_Void();
41366 return resultobj;
41367 fail:
41368 return NULL;
41369 }
41370
41371
41372 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41373 PyObject *resultobj = 0;
41374 wxMenu *arg1 = (wxMenu *) 0 ;
41375 int arg2 ;
41376 bool result;
41377 void *argp1 = 0 ;
41378 int res1 = 0 ;
41379 int val2 ;
41380 int ecode2 = 0 ;
41381 PyObject * obj0 = 0 ;
41382 PyObject * obj1 = 0 ;
41383 char * kwnames[] = {
41384 (char *) "self",(char *) "id", NULL
41385 };
41386
41387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41389 if (!SWIG_IsOK(res1)) {
41390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41391 }
41392 arg1 = reinterpret_cast< wxMenu * >(argp1);
41393 ecode2 = SWIG_AsVal_int(obj1, &val2);
41394 if (!SWIG_IsOK(ecode2)) {
41395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41396 }
41397 arg2 = static_cast< int >(val2);
41398 {
41399 PyThreadState* __tstate = wxPyBeginAllowThreads();
41400 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41401 wxPyEndAllowThreads(__tstate);
41402 if (PyErr_Occurred()) SWIG_fail;
41403 }
41404 {
41405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41406 }
41407 return resultobj;
41408 fail:
41409 return NULL;
41410 }
41411
41412
41413 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41414 PyObject *resultobj = 0;
41415 wxMenu *arg1 = (wxMenu *) 0 ;
41416 int arg2 ;
41417 wxString *arg3 = 0 ;
41418 void *argp1 = 0 ;
41419 int res1 = 0 ;
41420 int val2 ;
41421 int ecode2 = 0 ;
41422 bool temp3 = false ;
41423 PyObject * obj0 = 0 ;
41424 PyObject * obj1 = 0 ;
41425 PyObject * obj2 = 0 ;
41426 char * kwnames[] = {
41427 (char *) "self",(char *) "id",(char *) "label", NULL
41428 };
41429
41430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41432 if (!SWIG_IsOK(res1)) {
41433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41434 }
41435 arg1 = reinterpret_cast< wxMenu * >(argp1);
41436 ecode2 = SWIG_AsVal_int(obj1, &val2);
41437 if (!SWIG_IsOK(ecode2)) {
41438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41439 }
41440 arg2 = static_cast< int >(val2);
41441 {
41442 arg3 = wxString_in_helper(obj2);
41443 if (arg3 == NULL) SWIG_fail;
41444 temp3 = true;
41445 }
41446 {
41447 PyThreadState* __tstate = wxPyBeginAllowThreads();
41448 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41449 wxPyEndAllowThreads(__tstate);
41450 if (PyErr_Occurred()) SWIG_fail;
41451 }
41452 resultobj = SWIG_Py_Void();
41453 {
41454 if (temp3)
41455 delete arg3;
41456 }
41457 return resultobj;
41458 fail:
41459 {
41460 if (temp3)
41461 delete arg3;
41462 }
41463 return NULL;
41464 }
41465
41466
41467 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41468 PyObject *resultobj = 0;
41469 wxMenu *arg1 = (wxMenu *) 0 ;
41470 int arg2 ;
41471 wxString result;
41472 void *argp1 = 0 ;
41473 int res1 = 0 ;
41474 int val2 ;
41475 int ecode2 = 0 ;
41476 PyObject * obj0 = 0 ;
41477 PyObject * obj1 = 0 ;
41478 char * kwnames[] = {
41479 (char *) "self",(char *) "id", NULL
41480 };
41481
41482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41484 if (!SWIG_IsOK(res1)) {
41485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41486 }
41487 arg1 = reinterpret_cast< wxMenu * >(argp1);
41488 ecode2 = SWIG_AsVal_int(obj1, &val2);
41489 if (!SWIG_IsOK(ecode2)) {
41490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41491 }
41492 arg2 = static_cast< int >(val2);
41493 {
41494 PyThreadState* __tstate = wxPyBeginAllowThreads();
41495 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41496 wxPyEndAllowThreads(__tstate);
41497 if (PyErr_Occurred()) SWIG_fail;
41498 }
41499 {
41500 #if wxUSE_UNICODE
41501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41502 #else
41503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41504 #endif
41505 }
41506 return resultobj;
41507 fail:
41508 return NULL;
41509 }
41510
41511
41512 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41513 PyObject *resultobj = 0;
41514 wxMenu *arg1 = (wxMenu *) 0 ;
41515 int arg2 ;
41516 wxString *arg3 = 0 ;
41517 void *argp1 = 0 ;
41518 int res1 = 0 ;
41519 int val2 ;
41520 int ecode2 = 0 ;
41521 bool temp3 = false ;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 PyObject * obj2 = 0 ;
41525 char * kwnames[] = {
41526 (char *) "self",(char *) "id",(char *) "helpString", NULL
41527 };
41528
41529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41531 if (!SWIG_IsOK(res1)) {
41532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41533 }
41534 arg1 = reinterpret_cast< wxMenu * >(argp1);
41535 ecode2 = SWIG_AsVal_int(obj1, &val2);
41536 if (!SWIG_IsOK(ecode2)) {
41537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41538 }
41539 arg2 = static_cast< int >(val2);
41540 {
41541 arg3 = wxString_in_helper(obj2);
41542 if (arg3 == NULL) SWIG_fail;
41543 temp3 = true;
41544 }
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 resultobj = SWIG_Py_Void();
41552 {
41553 if (temp3)
41554 delete arg3;
41555 }
41556 return resultobj;
41557 fail:
41558 {
41559 if (temp3)
41560 delete arg3;
41561 }
41562 return NULL;
41563 }
41564
41565
41566 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41567 PyObject *resultobj = 0;
41568 wxMenu *arg1 = (wxMenu *) 0 ;
41569 int arg2 ;
41570 wxString result;
41571 void *argp1 = 0 ;
41572 int res1 = 0 ;
41573 int val2 ;
41574 int ecode2 = 0 ;
41575 PyObject * obj0 = 0 ;
41576 PyObject * obj1 = 0 ;
41577 char * kwnames[] = {
41578 (char *) "self",(char *) "id", NULL
41579 };
41580
41581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41583 if (!SWIG_IsOK(res1)) {
41584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41585 }
41586 arg1 = reinterpret_cast< wxMenu * >(argp1);
41587 ecode2 = SWIG_AsVal_int(obj1, &val2);
41588 if (!SWIG_IsOK(ecode2)) {
41589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41590 }
41591 arg2 = static_cast< int >(val2);
41592 {
41593 PyThreadState* __tstate = wxPyBeginAllowThreads();
41594 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 {
41599 #if wxUSE_UNICODE
41600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41601 #else
41602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41603 #endif
41604 }
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41612 PyObject *resultobj = 0;
41613 wxMenu *arg1 = (wxMenu *) 0 ;
41614 wxString *arg2 = 0 ;
41615 void *argp1 = 0 ;
41616 int res1 = 0 ;
41617 bool temp2 = false ;
41618 PyObject * obj0 = 0 ;
41619 PyObject * obj1 = 0 ;
41620 char * kwnames[] = {
41621 (char *) "self",(char *) "title", NULL
41622 };
41623
41624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41626 if (!SWIG_IsOK(res1)) {
41627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41628 }
41629 arg1 = reinterpret_cast< wxMenu * >(argp1);
41630 {
41631 arg2 = wxString_in_helper(obj1);
41632 if (arg2 == NULL) SWIG_fail;
41633 temp2 = true;
41634 }
41635 {
41636 PyThreadState* __tstate = wxPyBeginAllowThreads();
41637 (arg1)->SetTitle((wxString const &)*arg2);
41638 wxPyEndAllowThreads(__tstate);
41639 if (PyErr_Occurred()) SWIG_fail;
41640 }
41641 resultobj = SWIG_Py_Void();
41642 {
41643 if (temp2)
41644 delete arg2;
41645 }
41646 return resultobj;
41647 fail:
41648 {
41649 if (temp2)
41650 delete arg2;
41651 }
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41657 PyObject *resultobj = 0;
41658 wxMenu *arg1 = (wxMenu *) 0 ;
41659 wxString result;
41660 void *argp1 = 0 ;
41661 int res1 = 0 ;
41662 PyObject *swig_obj[1] ;
41663
41664 if (!args) SWIG_fail;
41665 swig_obj[0] = args;
41666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41667 if (!SWIG_IsOK(res1)) {
41668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41669 }
41670 arg1 = reinterpret_cast< wxMenu * >(argp1);
41671 {
41672 PyThreadState* __tstate = wxPyBeginAllowThreads();
41673 result = ((wxMenu const *)arg1)->GetTitle();
41674 wxPyEndAllowThreads(__tstate);
41675 if (PyErr_Occurred()) SWIG_fail;
41676 }
41677 {
41678 #if wxUSE_UNICODE
41679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41680 #else
41681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41682 #endif
41683 }
41684 return resultobj;
41685 fail:
41686 return NULL;
41687 }
41688
41689
41690 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41691 PyObject *resultobj = 0;
41692 wxMenu *arg1 = (wxMenu *) 0 ;
41693 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41694 void *argp1 = 0 ;
41695 int res1 = 0 ;
41696 void *argp2 = 0 ;
41697 int res2 = 0 ;
41698 PyObject * obj0 = 0 ;
41699 PyObject * obj1 = 0 ;
41700 char * kwnames[] = {
41701 (char *) "self",(char *) "handler", NULL
41702 };
41703
41704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41706 if (!SWIG_IsOK(res1)) {
41707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41708 }
41709 arg1 = reinterpret_cast< wxMenu * >(argp1);
41710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41711 if (!SWIG_IsOK(res2)) {
41712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41713 }
41714 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41715 {
41716 PyThreadState* __tstate = wxPyBeginAllowThreads();
41717 (arg1)->SetEventHandler(arg2);
41718 wxPyEndAllowThreads(__tstate);
41719 if (PyErr_Occurred()) SWIG_fail;
41720 }
41721 resultobj = SWIG_Py_Void();
41722 return resultobj;
41723 fail:
41724 return NULL;
41725 }
41726
41727
41728 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41729 PyObject *resultobj = 0;
41730 wxMenu *arg1 = (wxMenu *) 0 ;
41731 wxEvtHandler *result = 0 ;
41732 void *argp1 = 0 ;
41733 int res1 = 0 ;
41734 PyObject *swig_obj[1] ;
41735
41736 if (!args) SWIG_fail;
41737 swig_obj[0] = args;
41738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41739 if (!SWIG_IsOK(res1)) {
41740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41741 }
41742 arg1 = reinterpret_cast< wxMenu * >(argp1);
41743 {
41744 PyThreadState* __tstate = wxPyBeginAllowThreads();
41745 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41746 wxPyEndAllowThreads(__tstate);
41747 if (PyErr_Occurred()) SWIG_fail;
41748 }
41749 {
41750 resultobj = wxPyMake_wxObject(result, 0);
41751 }
41752 return resultobj;
41753 fail:
41754 return NULL;
41755 }
41756
41757
41758 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41759 PyObject *resultobj = 0;
41760 wxMenu *arg1 = (wxMenu *) 0 ;
41761 wxWindow *arg2 = (wxWindow *) 0 ;
41762 void *argp1 = 0 ;
41763 int res1 = 0 ;
41764 void *argp2 = 0 ;
41765 int res2 = 0 ;
41766 PyObject * obj0 = 0 ;
41767 PyObject * obj1 = 0 ;
41768 char * kwnames[] = {
41769 (char *) "self",(char *) "win", NULL
41770 };
41771
41772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41774 if (!SWIG_IsOK(res1)) {
41775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41776 }
41777 arg1 = reinterpret_cast< wxMenu * >(argp1);
41778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41779 if (!SWIG_IsOK(res2)) {
41780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41781 }
41782 arg2 = reinterpret_cast< wxWindow * >(argp2);
41783 {
41784 PyThreadState* __tstate = wxPyBeginAllowThreads();
41785 (arg1)->SetInvokingWindow(arg2);
41786 wxPyEndAllowThreads(__tstate);
41787 if (PyErr_Occurred()) SWIG_fail;
41788 }
41789 resultobj = SWIG_Py_Void();
41790 return resultobj;
41791 fail:
41792 return NULL;
41793 }
41794
41795
41796 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41797 PyObject *resultobj = 0;
41798 wxMenu *arg1 = (wxMenu *) 0 ;
41799 wxWindow *result = 0 ;
41800 void *argp1 = 0 ;
41801 int res1 = 0 ;
41802 PyObject *swig_obj[1] ;
41803
41804 if (!args) SWIG_fail;
41805 swig_obj[0] = args;
41806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41807 if (!SWIG_IsOK(res1)) {
41808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41809 }
41810 arg1 = reinterpret_cast< wxMenu * >(argp1);
41811 {
41812 PyThreadState* __tstate = wxPyBeginAllowThreads();
41813 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41814 wxPyEndAllowThreads(__tstate);
41815 if (PyErr_Occurred()) SWIG_fail;
41816 }
41817 {
41818 resultobj = wxPyMake_wxObject(result, 0);
41819 }
41820 return resultobj;
41821 fail:
41822 return NULL;
41823 }
41824
41825
41826 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41827 PyObject *resultobj = 0;
41828 wxMenu *arg1 = (wxMenu *) 0 ;
41829 long result;
41830 void *argp1 = 0 ;
41831 int res1 = 0 ;
41832 PyObject *swig_obj[1] ;
41833
41834 if (!args) SWIG_fail;
41835 swig_obj[0] = args;
41836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41837 if (!SWIG_IsOK(res1)) {
41838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41839 }
41840 arg1 = reinterpret_cast< wxMenu * >(argp1);
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 result = (long)((wxMenu const *)arg1)->GetStyle();
41844 wxPyEndAllowThreads(__tstate);
41845 if (PyErr_Occurred()) SWIG_fail;
41846 }
41847 resultobj = SWIG_From_long(static_cast< long >(result));
41848 return resultobj;
41849 fail:
41850 return NULL;
41851 }
41852
41853
41854 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41855 PyObject *resultobj = 0;
41856 wxMenu *arg1 = (wxMenu *) 0 ;
41857 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41858 void *argp1 = 0 ;
41859 int res1 = 0 ;
41860 void *argp2 = 0 ;
41861 int res2 = 0 ;
41862 PyObject * obj0 = 0 ;
41863 PyObject * obj1 = 0 ;
41864 char * kwnames[] = {
41865 (char *) "self",(char *) "source", NULL
41866 };
41867
41868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41870 if (!SWIG_IsOK(res1)) {
41871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41872 }
41873 arg1 = reinterpret_cast< wxMenu * >(argp1);
41874 if (obj1) {
41875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41876 if (!SWIG_IsOK(res2)) {
41877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41878 }
41879 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41880 }
41881 {
41882 PyThreadState* __tstate = wxPyBeginAllowThreads();
41883 (arg1)->UpdateUI(arg2);
41884 wxPyEndAllowThreads(__tstate);
41885 if (PyErr_Occurred()) SWIG_fail;
41886 }
41887 resultobj = SWIG_Py_Void();
41888 return resultobj;
41889 fail:
41890 return NULL;
41891 }
41892
41893
41894 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41895 PyObject *resultobj = 0;
41896 wxMenu *arg1 = (wxMenu *) 0 ;
41897 wxMenuBar *result = 0 ;
41898 void *argp1 = 0 ;
41899 int res1 = 0 ;
41900 PyObject *swig_obj[1] ;
41901
41902 if (!args) SWIG_fail;
41903 swig_obj[0] = args;
41904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41905 if (!SWIG_IsOK(res1)) {
41906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41907 }
41908 arg1 = reinterpret_cast< wxMenu * >(argp1);
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 {
41916 resultobj = wxPyMake_wxObject(result, (bool)0);
41917 }
41918 return resultobj;
41919 fail:
41920 return NULL;
41921 }
41922
41923
41924 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41925 PyObject *resultobj = 0;
41926 wxMenu *arg1 = (wxMenu *) 0 ;
41927 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41928 void *argp1 = 0 ;
41929 int res1 = 0 ;
41930 void *argp2 = 0 ;
41931 int res2 = 0 ;
41932 PyObject * obj0 = 0 ;
41933 PyObject * obj1 = 0 ;
41934 char * kwnames[] = {
41935 (char *) "self",(char *) "menubar", NULL
41936 };
41937
41938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41940 if (!SWIG_IsOK(res1)) {
41941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41942 }
41943 arg1 = reinterpret_cast< wxMenu * >(argp1);
41944 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41945 if (!SWIG_IsOK(res2)) {
41946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41947 }
41948 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41949 {
41950 PyThreadState* __tstate = wxPyBeginAllowThreads();
41951 (arg1)->Attach(arg2);
41952 wxPyEndAllowThreads(__tstate);
41953 if (PyErr_Occurred()) SWIG_fail;
41954 }
41955 resultobj = SWIG_Py_Void();
41956 return resultobj;
41957 fail:
41958 return NULL;
41959 }
41960
41961
41962 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41963 PyObject *resultobj = 0;
41964 wxMenu *arg1 = (wxMenu *) 0 ;
41965 void *argp1 = 0 ;
41966 int res1 = 0 ;
41967 PyObject *swig_obj[1] ;
41968
41969 if (!args) SWIG_fail;
41970 swig_obj[0] = args;
41971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41972 if (!SWIG_IsOK(res1)) {
41973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41974 }
41975 arg1 = reinterpret_cast< wxMenu * >(argp1);
41976 {
41977 PyThreadState* __tstate = wxPyBeginAllowThreads();
41978 (arg1)->Detach();
41979 wxPyEndAllowThreads(__tstate);
41980 if (PyErr_Occurred()) SWIG_fail;
41981 }
41982 resultobj = SWIG_Py_Void();
41983 return resultobj;
41984 fail:
41985 return NULL;
41986 }
41987
41988
41989 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41990 PyObject *resultobj = 0;
41991 wxMenu *arg1 = (wxMenu *) 0 ;
41992 bool result;
41993 void *argp1 = 0 ;
41994 int res1 = 0 ;
41995 PyObject *swig_obj[1] ;
41996
41997 if (!args) SWIG_fail;
41998 swig_obj[0] = args;
41999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42000 if (!SWIG_IsOK(res1)) {
42001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42002 }
42003 arg1 = reinterpret_cast< wxMenu * >(argp1);
42004 {
42005 PyThreadState* __tstate = wxPyBeginAllowThreads();
42006 result = (bool)((wxMenu const *)arg1)->IsAttached();
42007 wxPyEndAllowThreads(__tstate);
42008 if (PyErr_Occurred()) SWIG_fail;
42009 }
42010 {
42011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42012 }
42013 return resultobj;
42014 fail:
42015 return NULL;
42016 }
42017
42018
42019 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42020 PyObject *resultobj = 0;
42021 wxMenu *arg1 = (wxMenu *) 0 ;
42022 wxMenu *arg2 = (wxMenu *) 0 ;
42023 void *argp1 = 0 ;
42024 int res1 = 0 ;
42025 void *argp2 = 0 ;
42026 int res2 = 0 ;
42027 PyObject * obj0 = 0 ;
42028 PyObject * obj1 = 0 ;
42029 char * kwnames[] = {
42030 (char *) "self",(char *) "parent", NULL
42031 };
42032
42033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42035 if (!SWIG_IsOK(res1)) {
42036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42037 }
42038 arg1 = reinterpret_cast< wxMenu * >(argp1);
42039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42040 if (!SWIG_IsOK(res2)) {
42041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42042 }
42043 arg2 = reinterpret_cast< wxMenu * >(argp2);
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 (arg1)->SetParent(arg2);
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 resultobj = SWIG_Py_Void();
42051 return resultobj;
42052 fail:
42053 return NULL;
42054 }
42055
42056
42057 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42058 PyObject *resultobj = 0;
42059 wxMenu *arg1 = (wxMenu *) 0 ;
42060 wxMenu *result = 0 ;
42061 void *argp1 = 0 ;
42062 int res1 = 0 ;
42063 PyObject *swig_obj[1] ;
42064
42065 if (!args) SWIG_fail;
42066 swig_obj[0] = args;
42067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42068 if (!SWIG_IsOK(res1)) {
42069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42070 }
42071 arg1 = reinterpret_cast< wxMenu * >(argp1);
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42075 wxPyEndAllowThreads(__tstate);
42076 if (PyErr_Occurred()) SWIG_fail;
42077 }
42078 {
42079 resultobj = wxPyMake_wxObject(result, 0);
42080 }
42081 return resultobj;
42082 fail:
42083 return NULL;
42084 }
42085
42086
42087 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42088 PyObject *obj;
42089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42090 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42091 return SWIG_Py_Void();
42092 }
42093
42094 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42095 return SWIG_Python_InitShadowInstance(args);
42096 }
42097
42098 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj = 0;
42100 long arg1 = (long) 0 ;
42101 wxMenuBar *result = 0 ;
42102 long val1 ;
42103 int ecode1 = 0 ;
42104 PyObject * obj0 = 0 ;
42105 char * kwnames[] = {
42106 (char *) "style", NULL
42107 };
42108
42109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42110 if (obj0) {
42111 ecode1 = SWIG_AsVal_long(obj0, &val1);
42112 if (!SWIG_IsOK(ecode1)) {
42113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42114 }
42115 arg1 = static_cast< long >(val1);
42116 }
42117 {
42118 if (!wxPyCheckForApp()) SWIG_fail;
42119 PyThreadState* __tstate = wxPyBeginAllowThreads();
42120 result = (wxMenuBar *)new wxMenuBar(arg1);
42121 wxPyEndAllowThreads(__tstate);
42122 if (PyErr_Occurred()) SWIG_fail;
42123 }
42124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42125 return resultobj;
42126 fail:
42127 return NULL;
42128 }
42129
42130
42131 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj = 0;
42133 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42134 wxMenu *arg2 = (wxMenu *) 0 ;
42135 wxString *arg3 = 0 ;
42136 bool result;
42137 void *argp1 = 0 ;
42138 int res1 = 0 ;
42139 void *argp2 = 0 ;
42140 int res2 = 0 ;
42141 bool temp3 = false ;
42142 PyObject * obj0 = 0 ;
42143 PyObject * obj1 = 0 ;
42144 PyObject * obj2 = 0 ;
42145 char * kwnames[] = {
42146 (char *) "self",(char *) "menu",(char *) "title", NULL
42147 };
42148
42149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42151 if (!SWIG_IsOK(res1)) {
42152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42153 }
42154 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42156 if (!SWIG_IsOK(res2)) {
42157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42158 }
42159 arg2 = reinterpret_cast< wxMenu * >(argp2);
42160 {
42161 arg3 = wxString_in_helper(obj2);
42162 if (arg3 == NULL) SWIG_fail;
42163 temp3 = true;
42164 }
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 {
42172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42173 }
42174 {
42175 if (temp3)
42176 delete arg3;
42177 }
42178 return resultobj;
42179 fail:
42180 {
42181 if (temp3)
42182 delete arg3;
42183 }
42184 return NULL;
42185 }
42186
42187
42188 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42189 PyObject *resultobj = 0;
42190 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42191 size_t arg2 ;
42192 wxMenu *arg3 = (wxMenu *) 0 ;
42193 wxString *arg4 = 0 ;
42194 bool result;
42195 void *argp1 = 0 ;
42196 int res1 = 0 ;
42197 size_t val2 ;
42198 int ecode2 = 0 ;
42199 void *argp3 = 0 ;
42200 int res3 = 0 ;
42201 bool temp4 = false ;
42202 PyObject * obj0 = 0 ;
42203 PyObject * obj1 = 0 ;
42204 PyObject * obj2 = 0 ;
42205 PyObject * obj3 = 0 ;
42206 char * kwnames[] = {
42207 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42208 };
42209
42210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42212 if (!SWIG_IsOK(res1)) {
42213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42214 }
42215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42216 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42217 if (!SWIG_IsOK(ecode2)) {
42218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42219 }
42220 arg2 = static_cast< size_t >(val2);
42221 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42222 if (!SWIG_IsOK(res3)) {
42223 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42224 }
42225 arg3 = reinterpret_cast< wxMenu * >(argp3);
42226 {
42227 arg4 = wxString_in_helper(obj3);
42228 if (arg4 == NULL) SWIG_fail;
42229 temp4 = true;
42230 }
42231 {
42232 PyThreadState* __tstate = wxPyBeginAllowThreads();
42233 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42234 wxPyEndAllowThreads(__tstate);
42235 if (PyErr_Occurred()) SWIG_fail;
42236 }
42237 {
42238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42239 }
42240 {
42241 if (temp4)
42242 delete arg4;
42243 }
42244 return resultobj;
42245 fail:
42246 {
42247 if (temp4)
42248 delete arg4;
42249 }
42250 return NULL;
42251 }
42252
42253
42254 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42255 PyObject *resultobj = 0;
42256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42257 size_t result;
42258 void *argp1 = 0 ;
42259 int res1 = 0 ;
42260 PyObject *swig_obj[1] ;
42261
42262 if (!args) SWIG_fail;
42263 swig_obj[0] = args;
42264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42265 if (!SWIG_IsOK(res1)) {
42266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42267 }
42268 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42269 {
42270 PyThreadState* __tstate = wxPyBeginAllowThreads();
42271 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42272 wxPyEndAllowThreads(__tstate);
42273 if (PyErr_Occurred()) SWIG_fail;
42274 }
42275 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42276 return resultobj;
42277 fail:
42278 return NULL;
42279 }
42280
42281
42282 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42283 PyObject *resultobj = 0;
42284 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42285 size_t arg2 ;
42286 wxMenu *result = 0 ;
42287 void *argp1 = 0 ;
42288 int res1 = 0 ;
42289 size_t val2 ;
42290 int ecode2 = 0 ;
42291 PyObject * obj0 = 0 ;
42292 PyObject * obj1 = 0 ;
42293 char * kwnames[] = {
42294 (char *) "self",(char *) "pos", NULL
42295 };
42296
42297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42299 if (!SWIG_IsOK(res1)) {
42300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42301 }
42302 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42303 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42304 if (!SWIG_IsOK(ecode2)) {
42305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42306 }
42307 arg2 = static_cast< size_t >(val2);
42308 {
42309 PyThreadState* __tstate = wxPyBeginAllowThreads();
42310 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42311 wxPyEndAllowThreads(__tstate);
42312 if (PyErr_Occurred()) SWIG_fail;
42313 }
42314 {
42315 resultobj = wxPyMake_wxObject(result, 0);
42316 }
42317 return resultobj;
42318 fail:
42319 return NULL;
42320 }
42321
42322
42323 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42324 PyObject *resultobj = 0;
42325 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42326 size_t arg2 ;
42327 wxMenu *arg3 = (wxMenu *) 0 ;
42328 wxString *arg4 = 0 ;
42329 wxMenu *result = 0 ;
42330 void *argp1 = 0 ;
42331 int res1 = 0 ;
42332 size_t val2 ;
42333 int ecode2 = 0 ;
42334 void *argp3 = 0 ;
42335 int res3 = 0 ;
42336 bool temp4 = false ;
42337 PyObject * obj0 = 0 ;
42338 PyObject * obj1 = 0 ;
42339 PyObject * obj2 = 0 ;
42340 PyObject * obj3 = 0 ;
42341 char * kwnames[] = {
42342 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42343 };
42344
42345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42347 if (!SWIG_IsOK(res1)) {
42348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42349 }
42350 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42351 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42352 if (!SWIG_IsOK(ecode2)) {
42353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42354 }
42355 arg2 = static_cast< size_t >(val2);
42356 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42357 if (!SWIG_IsOK(res3)) {
42358 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42359 }
42360 arg3 = reinterpret_cast< wxMenu * >(argp3);
42361 {
42362 arg4 = wxString_in_helper(obj3);
42363 if (arg4 == NULL) SWIG_fail;
42364 temp4 = true;
42365 }
42366 {
42367 PyThreadState* __tstate = wxPyBeginAllowThreads();
42368 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42369 wxPyEndAllowThreads(__tstate);
42370 if (PyErr_Occurred()) SWIG_fail;
42371 }
42372 {
42373 resultobj = wxPyMake_wxObject(result, 0);
42374 }
42375 {
42376 if (temp4)
42377 delete arg4;
42378 }
42379 return resultobj;
42380 fail:
42381 {
42382 if (temp4)
42383 delete arg4;
42384 }
42385 return NULL;
42386 }
42387
42388
42389 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42390 PyObject *resultobj = 0;
42391 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42392 size_t arg2 ;
42393 wxMenu *result = 0 ;
42394 void *argp1 = 0 ;
42395 int res1 = 0 ;
42396 size_t val2 ;
42397 int ecode2 = 0 ;
42398 PyObject * obj0 = 0 ;
42399 PyObject * obj1 = 0 ;
42400 char * kwnames[] = {
42401 (char *) "self",(char *) "pos", NULL
42402 };
42403
42404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42406 if (!SWIG_IsOK(res1)) {
42407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42408 }
42409 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42410 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42411 if (!SWIG_IsOK(ecode2)) {
42412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42413 }
42414 arg2 = static_cast< size_t >(val2);
42415 {
42416 PyThreadState* __tstate = wxPyBeginAllowThreads();
42417 result = (wxMenu *)(arg1)->Remove(arg2);
42418 wxPyEndAllowThreads(__tstate);
42419 if (PyErr_Occurred()) SWIG_fail;
42420 }
42421 {
42422 resultobj = wxPyMake_wxObject(result, 0);
42423 }
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42431 PyObject *resultobj = 0;
42432 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42433 size_t arg2 ;
42434 bool arg3 ;
42435 void *argp1 = 0 ;
42436 int res1 = 0 ;
42437 size_t val2 ;
42438 int ecode2 = 0 ;
42439 bool val3 ;
42440 int ecode3 = 0 ;
42441 PyObject * obj0 = 0 ;
42442 PyObject * obj1 = 0 ;
42443 PyObject * obj2 = 0 ;
42444 char * kwnames[] = {
42445 (char *) "self",(char *) "pos",(char *) "enable", NULL
42446 };
42447
42448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42450 if (!SWIG_IsOK(res1)) {
42451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42452 }
42453 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42454 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42455 if (!SWIG_IsOK(ecode2)) {
42456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42457 }
42458 arg2 = static_cast< size_t >(val2);
42459 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42460 if (!SWIG_IsOK(ecode3)) {
42461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42462 }
42463 arg3 = static_cast< bool >(val3);
42464 {
42465 PyThreadState* __tstate = wxPyBeginAllowThreads();
42466 (arg1)->EnableTop(arg2,arg3);
42467 wxPyEndAllowThreads(__tstate);
42468 if (PyErr_Occurred()) SWIG_fail;
42469 }
42470 resultobj = SWIG_Py_Void();
42471 return resultobj;
42472 fail:
42473 return NULL;
42474 }
42475
42476
42477 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42478 PyObject *resultobj = 0;
42479 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42480 size_t arg2 ;
42481 bool result;
42482 void *argp1 = 0 ;
42483 int res1 = 0 ;
42484 size_t val2 ;
42485 int ecode2 = 0 ;
42486 PyObject * obj0 = 0 ;
42487 PyObject * obj1 = 0 ;
42488 char * kwnames[] = {
42489 (char *) "self",(char *) "pos", NULL
42490 };
42491
42492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42494 if (!SWIG_IsOK(res1)) {
42495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42496 }
42497 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42498 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42499 if (!SWIG_IsOK(ecode2)) {
42500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42501 }
42502 arg2 = static_cast< size_t >(val2);
42503 {
42504 PyThreadState* __tstate = wxPyBeginAllowThreads();
42505 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42506 wxPyEndAllowThreads(__tstate);
42507 if (PyErr_Occurred()) SWIG_fail;
42508 }
42509 {
42510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42511 }
42512 return resultobj;
42513 fail:
42514 return NULL;
42515 }
42516
42517
42518 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42519 PyObject *resultobj = 0;
42520 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42521 size_t arg2 ;
42522 wxString *arg3 = 0 ;
42523 void *argp1 = 0 ;
42524 int res1 = 0 ;
42525 size_t val2 ;
42526 int ecode2 = 0 ;
42527 bool temp3 = false ;
42528 PyObject * obj0 = 0 ;
42529 PyObject * obj1 = 0 ;
42530 PyObject * obj2 = 0 ;
42531 char * kwnames[] = {
42532 (char *) "self",(char *) "pos",(char *) "label", NULL
42533 };
42534
42535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42537 if (!SWIG_IsOK(res1)) {
42538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42539 }
42540 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42541 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42542 if (!SWIG_IsOK(ecode2)) {
42543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42544 }
42545 arg2 = static_cast< size_t >(val2);
42546 {
42547 arg3 = wxString_in_helper(obj2);
42548 if (arg3 == NULL) SWIG_fail;
42549 temp3 = true;
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 resultobj = SWIG_Py_Void();
42558 {
42559 if (temp3)
42560 delete arg3;
42561 }
42562 return resultobj;
42563 fail:
42564 {
42565 if (temp3)
42566 delete arg3;
42567 }
42568 return NULL;
42569 }
42570
42571
42572 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42573 PyObject *resultobj = 0;
42574 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42575 size_t arg2 ;
42576 wxString result;
42577 void *argp1 = 0 ;
42578 int res1 = 0 ;
42579 size_t val2 ;
42580 int ecode2 = 0 ;
42581 PyObject * obj0 = 0 ;
42582 PyObject * obj1 = 0 ;
42583 char * kwnames[] = {
42584 (char *) "self",(char *) "pos", NULL
42585 };
42586
42587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42589 if (!SWIG_IsOK(res1)) {
42590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42591 }
42592 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42593 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42594 if (!SWIG_IsOK(ecode2)) {
42595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42596 }
42597 arg2 = static_cast< size_t >(val2);
42598 {
42599 PyThreadState* __tstate = wxPyBeginAllowThreads();
42600 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42601 wxPyEndAllowThreads(__tstate);
42602 if (PyErr_Occurred()) SWIG_fail;
42603 }
42604 {
42605 #if wxUSE_UNICODE
42606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42607 #else
42608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42609 #endif
42610 }
42611 return resultobj;
42612 fail:
42613 return NULL;
42614 }
42615
42616
42617 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42618 PyObject *resultobj = 0;
42619 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42620 wxString *arg2 = 0 ;
42621 wxString *arg3 = 0 ;
42622 int result;
42623 void *argp1 = 0 ;
42624 int res1 = 0 ;
42625 bool temp2 = false ;
42626 bool temp3 = false ;
42627 PyObject * obj0 = 0 ;
42628 PyObject * obj1 = 0 ;
42629 PyObject * obj2 = 0 ;
42630 char * kwnames[] = {
42631 (char *) "self",(char *) "menu",(char *) "item", NULL
42632 };
42633
42634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42636 if (!SWIG_IsOK(res1)) {
42637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42638 }
42639 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42640 {
42641 arg2 = wxString_in_helper(obj1);
42642 if (arg2 == NULL) SWIG_fail;
42643 temp2 = true;
42644 }
42645 {
42646 arg3 = wxString_in_helper(obj2);
42647 if (arg3 == NULL) SWIG_fail;
42648 temp3 = true;
42649 }
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_From_int(static_cast< int >(result));
42657 {
42658 if (temp2)
42659 delete arg2;
42660 }
42661 {
42662 if (temp3)
42663 delete arg3;
42664 }
42665 return resultobj;
42666 fail:
42667 {
42668 if (temp2)
42669 delete arg2;
42670 }
42671 {
42672 if (temp3)
42673 delete arg3;
42674 }
42675 return NULL;
42676 }
42677
42678
42679 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42680 PyObject *resultobj = 0;
42681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42682 int arg2 ;
42683 wxMenuItem *result = 0 ;
42684 void *argp1 = 0 ;
42685 int res1 = 0 ;
42686 int val2 ;
42687 int ecode2 = 0 ;
42688 PyObject * obj0 = 0 ;
42689 PyObject * obj1 = 0 ;
42690 char * kwnames[] = {
42691 (char *) "self",(char *) "id", NULL
42692 };
42693
42694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42696 if (!SWIG_IsOK(res1)) {
42697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42698 }
42699 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42700 ecode2 = SWIG_AsVal_int(obj1, &val2);
42701 if (!SWIG_IsOK(ecode2)) {
42702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42703 }
42704 arg2 = static_cast< int >(val2);
42705 {
42706 PyThreadState* __tstate = wxPyBeginAllowThreads();
42707 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42708 wxPyEndAllowThreads(__tstate);
42709 if (PyErr_Occurred()) SWIG_fail;
42710 }
42711 {
42712 resultobj = wxPyMake_wxObject(result, (bool)0);
42713 }
42714 return resultobj;
42715 fail:
42716 return NULL;
42717 }
42718
42719
42720 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42721 PyObject *resultobj = 0;
42722 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42723 wxString *arg2 = 0 ;
42724 int result;
42725 void *argp1 = 0 ;
42726 int res1 = 0 ;
42727 bool temp2 = false ;
42728 PyObject * obj0 = 0 ;
42729 PyObject * obj1 = 0 ;
42730 char * kwnames[] = {
42731 (char *) "self",(char *) "title", NULL
42732 };
42733
42734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42736 if (!SWIG_IsOK(res1)) {
42737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42738 }
42739 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42740 {
42741 arg2 = wxString_in_helper(obj1);
42742 if (arg2 == NULL) SWIG_fail;
42743 temp2 = true;
42744 }
42745 {
42746 PyThreadState* __tstate = wxPyBeginAllowThreads();
42747 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 resultobj = SWIG_From_int(static_cast< int >(result));
42752 {
42753 if (temp2)
42754 delete arg2;
42755 }
42756 return resultobj;
42757 fail:
42758 {
42759 if (temp2)
42760 delete arg2;
42761 }
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj = 0;
42768 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42769 int arg2 ;
42770 bool arg3 ;
42771 void *argp1 = 0 ;
42772 int res1 = 0 ;
42773 int val2 ;
42774 int ecode2 = 0 ;
42775 bool val3 ;
42776 int ecode3 = 0 ;
42777 PyObject * obj0 = 0 ;
42778 PyObject * obj1 = 0 ;
42779 PyObject * obj2 = 0 ;
42780 char * kwnames[] = {
42781 (char *) "self",(char *) "id",(char *) "enable", NULL
42782 };
42783
42784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42786 if (!SWIG_IsOK(res1)) {
42787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42788 }
42789 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42790 ecode2 = SWIG_AsVal_int(obj1, &val2);
42791 if (!SWIG_IsOK(ecode2)) {
42792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42793 }
42794 arg2 = static_cast< int >(val2);
42795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42796 if (!SWIG_IsOK(ecode3)) {
42797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42798 }
42799 arg3 = static_cast< bool >(val3);
42800 {
42801 PyThreadState* __tstate = wxPyBeginAllowThreads();
42802 (arg1)->Enable(arg2,arg3);
42803 wxPyEndAllowThreads(__tstate);
42804 if (PyErr_Occurred()) SWIG_fail;
42805 }
42806 resultobj = SWIG_Py_Void();
42807 return resultobj;
42808 fail:
42809 return NULL;
42810 }
42811
42812
42813 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42814 PyObject *resultobj = 0;
42815 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42816 int arg2 ;
42817 bool arg3 ;
42818 void *argp1 = 0 ;
42819 int res1 = 0 ;
42820 int val2 ;
42821 int ecode2 = 0 ;
42822 bool val3 ;
42823 int ecode3 = 0 ;
42824 PyObject * obj0 = 0 ;
42825 PyObject * obj1 = 0 ;
42826 PyObject * obj2 = 0 ;
42827 char * kwnames[] = {
42828 (char *) "self",(char *) "id",(char *) "check", NULL
42829 };
42830
42831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42833 if (!SWIG_IsOK(res1)) {
42834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42835 }
42836 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42837 ecode2 = SWIG_AsVal_int(obj1, &val2);
42838 if (!SWIG_IsOK(ecode2)) {
42839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42840 }
42841 arg2 = static_cast< int >(val2);
42842 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42843 if (!SWIG_IsOK(ecode3)) {
42844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42845 }
42846 arg3 = static_cast< bool >(val3);
42847 {
42848 PyThreadState* __tstate = wxPyBeginAllowThreads();
42849 (arg1)->Check(arg2,arg3);
42850 wxPyEndAllowThreads(__tstate);
42851 if (PyErr_Occurred()) SWIG_fail;
42852 }
42853 resultobj = SWIG_Py_Void();
42854 return resultobj;
42855 fail:
42856 return NULL;
42857 }
42858
42859
42860 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42861 PyObject *resultobj = 0;
42862 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42863 int arg2 ;
42864 bool result;
42865 void *argp1 = 0 ;
42866 int res1 = 0 ;
42867 int val2 ;
42868 int ecode2 = 0 ;
42869 PyObject * obj0 = 0 ;
42870 PyObject * obj1 = 0 ;
42871 char * kwnames[] = {
42872 (char *) "self",(char *) "id", NULL
42873 };
42874
42875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42877 if (!SWIG_IsOK(res1)) {
42878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42879 }
42880 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42881 ecode2 = SWIG_AsVal_int(obj1, &val2);
42882 if (!SWIG_IsOK(ecode2)) {
42883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42884 }
42885 arg2 = static_cast< int >(val2);
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42889 wxPyEndAllowThreads(__tstate);
42890 if (PyErr_Occurred()) SWIG_fail;
42891 }
42892 {
42893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42894 }
42895 return resultobj;
42896 fail:
42897 return NULL;
42898 }
42899
42900
42901 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42902 PyObject *resultobj = 0;
42903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42904 int arg2 ;
42905 bool result;
42906 void *argp1 = 0 ;
42907 int res1 = 0 ;
42908 int val2 ;
42909 int ecode2 = 0 ;
42910 PyObject * obj0 = 0 ;
42911 PyObject * obj1 = 0 ;
42912 char * kwnames[] = {
42913 (char *) "self",(char *) "id", NULL
42914 };
42915
42916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42918 if (!SWIG_IsOK(res1)) {
42919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42920 }
42921 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42922 ecode2 = SWIG_AsVal_int(obj1, &val2);
42923 if (!SWIG_IsOK(ecode2)) {
42924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42925 }
42926 arg2 = static_cast< int >(val2);
42927 {
42928 PyThreadState* __tstate = wxPyBeginAllowThreads();
42929 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42930 wxPyEndAllowThreads(__tstate);
42931 if (PyErr_Occurred()) SWIG_fail;
42932 }
42933 {
42934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42935 }
42936 return resultobj;
42937 fail:
42938 return NULL;
42939 }
42940
42941
42942 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42943 PyObject *resultobj = 0;
42944 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42945 int arg2 ;
42946 wxString *arg3 = 0 ;
42947 void *argp1 = 0 ;
42948 int res1 = 0 ;
42949 int val2 ;
42950 int ecode2 = 0 ;
42951 bool temp3 = false ;
42952 PyObject * obj0 = 0 ;
42953 PyObject * obj1 = 0 ;
42954 PyObject * obj2 = 0 ;
42955 char * kwnames[] = {
42956 (char *) "self",(char *) "id",(char *) "label", NULL
42957 };
42958
42959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42961 if (!SWIG_IsOK(res1)) {
42962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42963 }
42964 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42965 ecode2 = SWIG_AsVal_int(obj1, &val2);
42966 if (!SWIG_IsOK(ecode2)) {
42967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42968 }
42969 arg2 = static_cast< int >(val2);
42970 {
42971 arg3 = wxString_in_helper(obj2);
42972 if (arg3 == NULL) SWIG_fail;
42973 temp3 = true;
42974 }
42975 {
42976 PyThreadState* __tstate = wxPyBeginAllowThreads();
42977 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42978 wxPyEndAllowThreads(__tstate);
42979 if (PyErr_Occurred()) SWIG_fail;
42980 }
42981 resultobj = SWIG_Py_Void();
42982 {
42983 if (temp3)
42984 delete arg3;
42985 }
42986 return resultobj;
42987 fail:
42988 {
42989 if (temp3)
42990 delete arg3;
42991 }
42992 return NULL;
42993 }
42994
42995
42996 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42997 PyObject *resultobj = 0;
42998 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42999 int arg2 ;
43000 wxString result;
43001 void *argp1 = 0 ;
43002 int res1 = 0 ;
43003 int val2 ;
43004 int ecode2 = 0 ;
43005 PyObject * obj0 = 0 ;
43006 PyObject * obj1 = 0 ;
43007 char * kwnames[] = {
43008 (char *) "self",(char *) "id", NULL
43009 };
43010
43011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43013 if (!SWIG_IsOK(res1)) {
43014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43015 }
43016 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43017 ecode2 = SWIG_AsVal_int(obj1, &val2);
43018 if (!SWIG_IsOK(ecode2)) {
43019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43020 }
43021 arg2 = static_cast< int >(val2);
43022 {
43023 PyThreadState* __tstate = wxPyBeginAllowThreads();
43024 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43025 wxPyEndAllowThreads(__tstate);
43026 if (PyErr_Occurred()) SWIG_fail;
43027 }
43028 {
43029 #if wxUSE_UNICODE
43030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43031 #else
43032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43033 #endif
43034 }
43035 return resultobj;
43036 fail:
43037 return NULL;
43038 }
43039
43040
43041 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43042 PyObject *resultobj = 0;
43043 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43044 int arg2 ;
43045 wxString *arg3 = 0 ;
43046 void *argp1 = 0 ;
43047 int res1 = 0 ;
43048 int val2 ;
43049 int ecode2 = 0 ;
43050 bool temp3 = false ;
43051 PyObject * obj0 = 0 ;
43052 PyObject * obj1 = 0 ;
43053 PyObject * obj2 = 0 ;
43054 char * kwnames[] = {
43055 (char *) "self",(char *) "id",(char *) "helpString", NULL
43056 };
43057
43058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43060 if (!SWIG_IsOK(res1)) {
43061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43062 }
43063 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43064 ecode2 = SWIG_AsVal_int(obj1, &val2);
43065 if (!SWIG_IsOK(ecode2)) {
43066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43067 }
43068 arg2 = static_cast< int >(val2);
43069 {
43070 arg3 = wxString_in_helper(obj2);
43071 if (arg3 == NULL) SWIG_fail;
43072 temp3 = true;
43073 }
43074 {
43075 PyThreadState* __tstate = wxPyBeginAllowThreads();
43076 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43077 wxPyEndAllowThreads(__tstate);
43078 if (PyErr_Occurred()) SWIG_fail;
43079 }
43080 resultobj = SWIG_Py_Void();
43081 {
43082 if (temp3)
43083 delete arg3;
43084 }
43085 return resultobj;
43086 fail:
43087 {
43088 if (temp3)
43089 delete arg3;
43090 }
43091 return NULL;
43092 }
43093
43094
43095 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43096 PyObject *resultobj = 0;
43097 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43098 int arg2 ;
43099 wxString result;
43100 void *argp1 = 0 ;
43101 int res1 = 0 ;
43102 int val2 ;
43103 int ecode2 = 0 ;
43104 PyObject * obj0 = 0 ;
43105 PyObject * obj1 = 0 ;
43106 char * kwnames[] = {
43107 (char *) "self",(char *) "id", NULL
43108 };
43109
43110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43112 if (!SWIG_IsOK(res1)) {
43113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43114 }
43115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43116 ecode2 = SWIG_AsVal_int(obj1, &val2);
43117 if (!SWIG_IsOK(ecode2)) {
43118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43119 }
43120 arg2 = static_cast< int >(val2);
43121 {
43122 PyThreadState* __tstate = wxPyBeginAllowThreads();
43123 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43124 wxPyEndAllowThreads(__tstate);
43125 if (PyErr_Occurred()) SWIG_fail;
43126 }
43127 {
43128 #if wxUSE_UNICODE
43129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43130 #else
43131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43132 #endif
43133 }
43134 return resultobj;
43135 fail:
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43141 PyObject *resultobj = 0;
43142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43143 wxFrame *result = 0 ;
43144 void *argp1 = 0 ;
43145 int res1 = 0 ;
43146 PyObject *swig_obj[1] ;
43147
43148 if (!args) SWIG_fail;
43149 swig_obj[0] = args;
43150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43151 if (!SWIG_IsOK(res1)) {
43152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43153 }
43154 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43155 {
43156 PyThreadState* __tstate = wxPyBeginAllowThreads();
43157 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43158 wxPyEndAllowThreads(__tstate);
43159 if (PyErr_Occurred()) SWIG_fail;
43160 }
43161 {
43162 resultobj = wxPyMake_wxObject(result, (bool)0);
43163 }
43164 return resultobj;
43165 fail:
43166 return NULL;
43167 }
43168
43169
43170 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43171 PyObject *resultobj = 0;
43172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43173 bool result;
43174 void *argp1 = 0 ;
43175 int res1 = 0 ;
43176 PyObject *swig_obj[1] ;
43177
43178 if (!args) SWIG_fail;
43179 swig_obj[0] = args;
43180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43181 if (!SWIG_IsOK(res1)) {
43182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43183 }
43184 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43185 {
43186 PyThreadState* __tstate = wxPyBeginAllowThreads();
43187 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43188 wxPyEndAllowThreads(__tstate);
43189 if (PyErr_Occurred()) SWIG_fail;
43190 }
43191 {
43192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43193 }
43194 return resultobj;
43195 fail:
43196 return NULL;
43197 }
43198
43199
43200 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43201 PyObject *resultobj = 0;
43202 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43203 wxFrame *arg2 = (wxFrame *) 0 ;
43204 void *argp1 = 0 ;
43205 int res1 = 0 ;
43206 void *argp2 = 0 ;
43207 int res2 = 0 ;
43208 PyObject * obj0 = 0 ;
43209 PyObject * obj1 = 0 ;
43210 char * kwnames[] = {
43211 (char *) "self",(char *) "frame", NULL
43212 };
43213
43214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43221 if (!SWIG_IsOK(res2)) {
43222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43223 }
43224 arg2 = reinterpret_cast< wxFrame * >(argp2);
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 (arg1)->Attach(arg2);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 resultobj = SWIG_Py_Void();
43232 return resultobj;
43233 fail:
43234 return NULL;
43235 }
43236
43237
43238 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43239 PyObject *resultobj = 0;
43240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43241 void *argp1 = 0 ;
43242 int res1 = 0 ;
43243 PyObject *swig_obj[1] ;
43244
43245 if (!args) SWIG_fail;
43246 swig_obj[0] = args;
43247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43248 if (!SWIG_IsOK(res1)) {
43249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43250 }
43251 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43252 {
43253 PyThreadState* __tstate = wxPyBeginAllowThreads();
43254 (arg1)->Detach();
43255 wxPyEndAllowThreads(__tstate);
43256 if (PyErr_Occurred()) SWIG_fail;
43257 }
43258 resultobj = SWIG_Py_Void();
43259 return resultobj;
43260 fail:
43261 return NULL;
43262 }
43263
43264
43265 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43266 PyObject *resultobj = 0;
43267 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43268 void *argp1 = 0 ;
43269 int res1 = 0 ;
43270 PyObject *swig_obj[1] ;
43271
43272 if (!args) SWIG_fail;
43273 swig_obj[0] = args;
43274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43275 if (!SWIG_IsOK(res1)) {
43276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43277 }
43278 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43279 {
43280 PyThreadState* __tstate = wxPyBeginAllowThreads();
43281 (arg1)->UpdateMenus();
43282 wxPyEndAllowThreads(__tstate);
43283 if (PyErr_Occurred()) SWIG_fail;
43284 }
43285 resultobj = SWIG_Py_Void();
43286 return resultobj;
43287 fail:
43288 return NULL;
43289 }
43290
43291
43292 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43293 PyObject *resultobj = 0;
43294 bool arg1 ;
43295 bool val1 ;
43296 int ecode1 = 0 ;
43297 PyObject * obj0 = 0 ;
43298 char * kwnames[] = {
43299 (char *) "enable", NULL
43300 };
43301
43302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43303 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43304 if (!SWIG_IsOK(ecode1)) {
43305 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43306 }
43307 arg1 = static_cast< bool >(val1);
43308 {
43309 PyThreadState* __tstate = wxPyBeginAllowThreads();
43310 wxMenuBar::SetAutoWindowMenu(arg1);
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 resultobj = SWIG_Py_Void();
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43322 PyObject *resultobj = 0;
43323 bool result;
43324
43325 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43326 {
43327 PyThreadState* __tstate = wxPyBeginAllowThreads();
43328 result = (bool)wxMenuBar::GetAutoWindowMenu();
43329 wxPyEndAllowThreads(__tstate);
43330 if (PyErr_Occurred()) SWIG_fail;
43331 }
43332 {
43333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43334 }
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43342 PyObject *obj;
43343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43344 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43345 return SWIG_Py_Void();
43346 }
43347
43348 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43349 return SWIG_Python_InitShadowInstance(args);
43350 }
43351
43352 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43353 PyObject *resultobj = 0;
43354 wxMenu *arg1 = (wxMenu *) NULL ;
43355 int arg2 = (int) wxID_ANY ;
43356 wxString const &arg3_defvalue = wxPyEmptyString ;
43357 wxString *arg3 = (wxString *) &arg3_defvalue ;
43358 wxString const &arg4_defvalue = wxPyEmptyString ;
43359 wxString *arg4 = (wxString *) &arg4_defvalue ;
43360 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43361 wxMenu *arg6 = (wxMenu *) NULL ;
43362 wxMenuItem *result = 0 ;
43363 void *argp1 = 0 ;
43364 int res1 = 0 ;
43365 int val2 ;
43366 int ecode2 = 0 ;
43367 bool temp3 = false ;
43368 bool temp4 = false ;
43369 int val5 ;
43370 int ecode5 = 0 ;
43371 void *argp6 = 0 ;
43372 int res6 = 0 ;
43373 PyObject * obj0 = 0 ;
43374 PyObject * obj1 = 0 ;
43375 PyObject * obj2 = 0 ;
43376 PyObject * obj3 = 0 ;
43377 PyObject * obj4 = 0 ;
43378 PyObject * obj5 = 0 ;
43379 char * kwnames[] = {
43380 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43381 };
43382
43383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43384 if (obj0) {
43385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenu * >(argp1);
43390 }
43391 if (obj1) {
43392 ecode2 = SWIG_AsVal_int(obj1, &val2);
43393 if (!SWIG_IsOK(ecode2)) {
43394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43395 }
43396 arg2 = static_cast< int >(val2);
43397 }
43398 if (obj2) {
43399 {
43400 arg3 = wxString_in_helper(obj2);
43401 if (arg3 == NULL) SWIG_fail;
43402 temp3 = true;
43403 }
43404 }
43405 if (obj3) {
43406 {
43407 arg4 = wxString_in_helper(obj3);
43408 if (arg4 == NULL) SWIG_fail;
43409 temp4 = true;
43410 }
43411 }
43412 if (obj4) {
43413 ecode5 = SWIG_AsVal_int(obj4, &val5);
43414 if (!SWIG_IsOK(ecode5)) {
43415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43416 }
43417 arg5 = static_cast< wxItemKind >(val5);
43418 }
43419 if (obj5) {
43420 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43421 if (!SWIG_IsOK(res6)) {
43422 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43423 }
43424 arg6 = reinterpret_cast< wxMenu * >(argp6);
43425 }
43426 {
43427 PyThreadState* __tstate = wxPyBeginAllowThreads();
43428 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43429 wxPyEndAllowThreads(__tstate);
43430 if (PyErr_Occurred()) SWIG_fail;
43431 }
43432 {
43433 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43434 }
43435 {
43436 if (temp3)
43437 delete arg3;
43438 }
43439 {
43440 if (temp4)
43441 delete arg4;
43442 }
43443 return resultobj;
43444 fail:
43445 {
43446 if (temp3)
43447 delete arg3;
43448 }
43449 {
43450 if (temp4)
43451 delete arg4;
43452 }
43453 return NULL;
43454 }
43455
43456
43457 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43458 PyObject *resultobj = 0;
43459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43460 void *argp1 = 0 ;
43461 int res1 = 0 ;
43462 PyObject *swig_obj[1] ;
43463
43464 if (!args) SWIG_fail;
43465 swig_obj[0] = args;
43466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43467 if (!SWIG_IsOK(res1)) {
43468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43469 }
43470 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43471 {
43472 PyThreadState* __tstate = wxPyBeginAllowThreads();
43473 delete arg1;
43474
43475 wxPyEndAllowThreads(__tstate);
43476 if (PyErr_Occurred()) SWIG_fail;
43477 }
43478 resultobj = SWIG_Py_Void();
43479 return resultobj;
43480 fail:
43481 return NULL;
43482 }
43483
43484
43485 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43486 PyObject *resultobj = 0;
43487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43488 wxMenu *result = 0 ;
43489 void *argp1 = 0 ;
43490 int res1 = 0 ;
43491 PyObject *swig_obj[1] ;
43492
43493 if (!args) SWIG_fail;
43494 swig_obj[0] = args;
43495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43496 if (!SWIG_IsOK(res1)) {
43497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43498 }
43499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43500 {
43501 PyThreadState* __tstate = wxPyBeginAllowThreads();
43502 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43503 wxPyEndAllowThreads(__tstate);
43504 if (PyErr_Occurred()) SWIG_fail;
43505 }
43506 {
43507 resultobj = wxPyMake_wxObject(result, 0);
43508 }
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43516 PyObject *resultobj = 0;
43517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43518 wxMenu *arg2 = (wxMenu *) 0 ;
43519 void *argp1 = 0 ;
43520 int res1 = 0 ;
43521 void *argp2 = 0 ;
43522 int res2 = 0 ;
43523 PyObject * obj0 = 0 ;
43524 PyObject * obj1 = 0 ;
43525 char * kwnames[] = {
43526 (char *) "self",(char *) "menu", NULL
43527 };
43528
43529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43531 if (!SWIG_IsOK(res1)) {
43532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43533 }
43534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43536 if (!SWIG_IsOK(res2)) {
43537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43538 }
43539 arg2 = reinterpret_cast< wxMenu * >(argp2);
43540 {
43541 PyThreadState* __tstate = wxPyBeginAllowThreads();
43542 (arg1)->SetMenu(arg2);
43543 wxPyEndAllowThreads(__tstate);
43544 if (PyErr_Occurred()) SWIG_fail;
43545 }
43546 resultobj = SWIG_Py_Void();
43547 return resultobj;
43548 fail:
43549 return NULL;
43550 }
43551
43552
43553 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43554 PyObject *resultobj = 0;
43555 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43556 int arg2 ;
43557 void *argp1 = 0 ;
43558 int res1 = 0 ;
43559 int val2 ;
43560 int ecode2 = 0 ;
43561 PyObject * obj0 = 0 ;
43562 PyObject * obj1 = 0 ;
43563 char * kwnames[] = {
43564 (char *) "self",(char *) "id", NULL
43565 };
43566
43567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43569 if (!SWIG_IsOK(res1)) {
43570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43571 }
43572 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43573 ecode2 = SWIG_AsVal_int(obj1, &val2);
43574 if (!SWIG_IsOK(ecode2)) {
43575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43576 }
43577 arg2 = static_cast< int >(val2);
43578 {
43579 PyThreadState* __tstate = wxPyBeginAllowThreads();
43580 (arg1)->SetId(arg2);
43581 wxPyEndAllowThreads(__tstate);
43582 if (PyErr_Occurred()) SWIG_fail;
43583 }
43584 resultobj = SWIG_Py_Void();
43585 return resultobj;
43586 fail:
43587 return NULL;
43588 }
43589
43590
43591 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43592 PyObject *resultobj = 0;
43593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43594 int result;
43595 void *argp1 = 0 ;
43596 int res1 = 0 ;
43597 PyObject *swig_obj[1] ;
43598
43599 if (!args) SWIG_fail;
43600 swig_obj[0] = args;
43601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43602 if (!SWIG_IsOK(res1)) {
43603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43604 }
43605 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43606 {
43607 PyThreadState* __tstate = wxPyBeginAllowThreads();
43608 result = (int)((wxMenuItem const *)arg1)->GetId();
43609 wxPyEndAllowThreads(__tstate);
43610 if (PyErr_Occurred()) SWIG_fail;
43611 }
43612 resultobj = SWIG_From_int(static_cast< int >(result));
43613 return resultobj;
43614 fail:
43615 return NULL;
43616 }
43617
43618
43619 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43620 PyObject *resultobj = 0;
43621 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43622 bool result;
43623 void *argp1 = 0 ;
43624 int res1 = 0 ;
43625 PyObject *swig_obj[1] ;
43626
43627 if (!args) SWIG_fail;
43628 swig_obj[0] = args;
43629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43630 if (!SWIG_IsOK(res1)) {
43631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43632 }
43633 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43634 {
43635 PyThreadState* __tstate = wxPyBeginAllowThreads();
43636 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43637 wxPyEndAllowThreads(__tstate);
43638 if (PyErr_Occurred()) SWIG_fail;
43639 }
43640 {
43641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43642 }
43643 return resultobj;
43644 fail:
43645 return NULL;
43646 }
43647
43648
43649 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43650 PyObject *resultobj = 0;
43651 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43652 wxString *arg2 = 0 ;
43653 void *argp1 = 0 ;
43654 int res1 = 0 ;
43655 bool temp2 = false ;
43656 PyObject * obj0 = 0 ;
43657 PyObject * obj1 = 0 ;
43658 char * kwnames[] = {
43659 (char *) "self",(char *) "str", NULL
43660 };
43661
43662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43664 if (!SWIG_IsOK(res1)) {
43665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43666 }
43667 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43668 {
43669 arg2 = wxString_in_helper(obj1);
43670 if (arg2 == NULL) SWIG_fail;
43671 temp2 = true;
43672 }
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 (arg1)->SetText((wxString const &)*arg2);
43676 wxPyEndAllowThreads(__tstate);
43677 if (PyErr_Occurred()) SWIG_fail;
43678 }
43679 resultobj = SWIG_Py_Void();
43680 {
43681 if (temp2)
43682 delete arg2;
43683 }
43684 return resultobj;
43685 fail:
43686 {
43687 if (temp2)
43688 delete arg2;
43689 }
43690 return NULL;
43691 }
43692
43693
43694 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43695 PyObject *resultobj = 0;
43696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43697 wxString result;
43698 void *argp1 = 0 ;
43699 int res1 = 0 ;
43700 PyObject *swig_obj[1] ;
43701
43702 if (!args) SWIG_fail;
43703 swig_obj[0] = args;
43704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43705 if (!SWIG_IsOK(res1)) {
43706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43707 }
43708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 result = ((wxMenuItem const *)arg1)->GetLabel();
43712 wxPyEndAllowThreads(__tstate);
43713 if (PyErr_Occurred()) SWIG_fail;
43714 }
43715 {
43716 #if wxUSE_UNICODE
43717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43718 #else
43719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43720 #endif
43721 }
43722 return resultobj;
43723 fail:
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43729 PyObject *resultobj = 0;
43730 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43731 wxString *result = 0 ;
43732 void *argp1 = 0 ;
43733 int res1 = 0 ;
43734 PyObject *swig_obj[1] ;
43735
43736 if (!args) SWIG_fail;
43737 swig_obj[0] = args;
43738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43739 if (!SWIG_IsOK(res1)) {
43740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43741 }
43742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43743 {
43744 PyThreadState* __tstate = wxPyBeginAllowThreads();
43745 {
43746 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43747 result = (wxString *) &_result_ref;
43748 }
43749 wxPyEndAllowThreads(__tstate);
43750 if (PyErr_Occurred()) SWIG_fail;
43751 }
43752 {
43753 #if wxUSE_UNICODE
43754 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43755 #else
43756 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43757 #endif
43758 }
43759 return resultobj;
43760 fail:
43761 return NULL;
43762 }
43763
43764
43765 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43766 PyObject *resultobj = 0;
43767 wxString *arg1 = 0 ;
43768 wxString result;
43769 bool temp1 = false ;
43770 PyObject * obj0 = 0 ;
43771 char * kwnames[] = {
43772 (char *) "text", NULL
43773 };
43774
43775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43776 {
43777 arg1 = wxString_in_helper(obj0);
43778 if (arg1 == NULL) SWIG_fail;
43779 temp1 = true;
43780 }
43781 {
43782 PyThreadState* __tstate = wxPyBeginAllowThreads();
43783 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43784 wxPyEndAllowThreads(__tstate);
43785 if (PyErr_Occurred()) SWIG_fail;
43786 }
43787 {
43788 #if wxUSE_UNICODE
43789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43790 #else
43791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43792 #endif
43793 }
43794 {
43795 if (temp1)
43796 delete arg1;
43797 }
43798 return resultobj;
43799 fail:
43800 {
43801 if (temp1)
43802 delete arg1;
43803 }
43804 return NULL;
43805 }
43806
43807
43808 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43809 PyObject *resultobj = 0;
43810 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43811 wxItemKind result;
43812 void *argp1 = 0 ;
43813 int res1 = 0 ;
43814 PyObject *swig_obj[1] ;
43815
43816 if (!args) SWIG_fail;
43817 swig_obj[0] = args;
43818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43819 if (!SWIG_IsOK(res1)) {
43820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43821 }
43822 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43823 {
43824 PyThreadState* __tstate = wxPyBeginAllowThreads();
43825 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 resultobj = SWIG_From_int(static_cast< int >(result));
43830 return resultobj;
43831 fail:
43832 return NULL;
43833 }
43834
43835
43836 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43837 PyObject *resultobj = 0;
43838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43839 wxItemKind arg2 ;
43840 void *argp1 = 0 ;
43841 int res1 = 0 ;
43842 int val2 ;
43843 int ecode2 = 0 ;
43844 PyObject * obj0 = 0 ;
43845 PyObject * obj1 = 0 ;
43846 char * kwnames[] = {
43847 (char *) "self",(char *) "kind", NULL
43848 };
43849
43850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43852 if (!SWIG_IsOK(res1)) {
43853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43854 }
43855 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43856 ecode2 = SWIG_AsVal_int(obj1, &val2);
43857 if (!SWIG_IsOK(ecode2)) {
43858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43859 }
43860 arg2 = static_cast< wxItemKind >(val2);
43861 {
43862 PyThreadState* __tstate = wxPyBeginAllowThreads();
43863 (arg1)->SetKind(arg2);
43864 wxPyEndAllowThreads(__tstate);
43865 if (PyErr_Occurred()) SWIG_fail;
43866 }
43867 resultobj = SWIG_Py_Void();
43868 return resultobj;
43869 fail:
43870 return NULL;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43875 PyObject *resultobj = 0;
43876 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43877 bool arg2 ;
43878 void *argp1 = 0 ;
43879 int res1 = 0 ;
43880 bool val2 ;
43881 int ecode2 = 0 ;
43882 PyObject * obj0 = 0 ;
43883 PyObject * obj1 = 0 ;
43884 char * kwnames[] = {
43885 (char *) "self",(char *) "checkable", NULL
43886 };
43887
43888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43890 if (!SWIG_IsOK(res1)) {
43891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43892 }
43893 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43894 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43895 if (!SWIG_IsOK(ecode2)) {
43896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43897 }
43898 arg2 = static_cast< bool >(val2);
43899 {
43900 PyThreadState* __tstate = wxPyBeginAllowThreads();
43901 (arg1)->SetCheckable(arg2);
43902 wxPyEndAllowThreads(__tstate);
43903 if (PyErr_Occurred()) SWIG_fail;
43904 }
43905 resultobj = SWIG_Py_Void();
43906 return resultobj;
43907 fail:
43908 return NULL;
43909 }
43910
43911
43912 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43913 PyObject *resultobj = 0;
43914 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43915 bool result;
43916 void *argp1 = 0 ;
43917 int res1 = 0 ;
43918 PyObject *swig_obj[1] ;
43919
43920 if (!args) SWIG_fail;
43921 swig_obj[0] = args;
43922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43923 if (!SWIG_IsOK(res1)) {
43924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43925 }
43926 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43927 {
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43930 wxPyEndAllowThreads(__tstate);
43931 if (PyErr_Occurred()) SWIG_fail;
43932 }
43933 {
43934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43935 }
43936 return resultobj;
43937 fail:
43938 return NULL;
43939 }
43940
43941
43942 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43943 PyObject *resultobj = 0;
43944 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43945 bool result;
43946 void *argp1 = 0 ;
43947 int res1 = 0 ;
43948 PyObject *swig_obj[1] ;
43949
43950 if (!args) SWIG_fail;
43951 swig_obj[0] = args;
43952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43953 if (!SWIG_IsOK(res1)) {
43954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43955 }
43956 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43957 {
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 {
43964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43965 }
43966 return resultobj;
43967 fail:
43968 return NULL;
43969 }
43970
43971
43972 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43973 PyObject *resultobj = 0;
43974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43975 wxMenu *arg2 = (wxMenu *) 0 ;
43976 void *argp1 = 0 ;
43977 int res1 = 0 ;
43978 void *argp2 = 0 ;
43979 int res2 = 0 ;
43980 PyObject * obj0 = 0 ;
43981 PyObject * obj1 = 0 ;
43982 char * kwnames[] = {
43983 (char *) "self",(char *) "menu", NULL
43984 };
43985
43986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43988 if (!SWIG_IsOK(res1)) {
43989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43990 }
43991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43993 if (!SWIG_IsOK(res2)) {
43994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43995 }
43996 arg2 = reinterpret_cast< wxMenu * >(argp2);
43997 {
43998 PyThreadState* __tstate = wxPyBeginAllowThreads();
43999 (arg1)->SetSubMenu(arg2);
44000 wxPyEndAllowThreads(__tstate);
44001 if (PyErr_Occurred()) SWIG_fail;
44002 }
44003 resultobj = SWIG_Py_Void();
44004 return resultobj;
44005 fail:
44006 return NULL;
44007 }
44008
44009
44010 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44011 PyObject *resultobj = 0;
44012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44013 wxMenu *result = 0 ;
44014 void *argp1 = 0 ;
44015 int res1 = 0 ;
44016 PyObject *swig_obj[1] ;
44017
44018 if (!args) SWIG_fail;
44019 swig_obj[0] = args;
44020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44021 if (!SWIG_IsOK(res1)) {
44022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44023 }
44024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44025 {
44026 PyThreadState* __tstate = wxPyBeginAllowThreads();
44027 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 {
44032 resultobj = wxPyMake_wxObject(result, 0);
44033 }
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44041 PyObject *resultobj = 0;
44042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44043 bool arg2 = (bool) true ;
44044 void *argp1 = 0 ;
44045 int res1 = 0 ;
44046 bool val2 ;
44047 int ecode2 = 0 ;
44048 PyObject * obj0 = 0 ;
44049 PyObject * obj1 = 0 ;
44050 char * kwnames[] = {
44051 (char *) "self",(char *) "enable", NULL
44052 };
44053
44054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44056 if (!SWIG_IsOK(res1)) {
44057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44058 }
44059 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44060 if (obj1) {
44061 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44062 if (!SWIG_IsOK(ecode2)) {
44063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44064 }
44065 arg2 = static_cast< bool >(val2);
44066 }
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 (arg1)->Enable(arg2);
44070 wxPyEndAllowThreads(__tstate);
44071 if (PyErr_Occurred()) SWIG_fail;
44072 }
44073 resultobj = SWIG_Py_Void();
44074 return resultobj;
44075 fail:
44076 return NULL;
44077 }
44078
44079
44080 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44081 PyObject *resultobj = 0;
44082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44083 bool result;
44084 void *argp1 = 0 ;
44085 int res1 = 0 ;
44086 PyObject *swig_obj[1] ;
44087
44088 if (!args) SWIG_fail;
44089 swig_obj[0] = args;
44090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44091 if (!SWIG_IsOK(res1)) {
44092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44093 }
44094 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44098 wxPyEndAllowThreads(__tstate);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 }
44101 {
44102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44103 }
44104 return resultobj;
44105 fail:
44106 return NULL;
44107 }
44108
44109
44110 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44111 PyObject *resultobj = 0;
44112 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44113 bool arg2 = (bool) true ;
44114 void *argp1 = 0 ;
44115 int res1 = 0 ;
44116 bool val2 ;
44117 int ecode2 = 0 ;
44118 PyObject * obj0 = 0 ;
44119 PyObject * obj1 = 0 ;
44120 char * kwnames[] = {
44121 (char *) "self",(char *) "check", NULL
44122 };
44123
44124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44126 if (!SWIG_IsOK(res1)) {
44127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44128 }
44129 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44130 if (obj1) {
44131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44132 if (!SWIG_IsOK(ecode2)) {
44133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44134 }
44135 arg2 = static_cast< bool >(val2);
44136 }
44137 {
44138 PyThreadState* __tstate = wxPyBeginAllowThreads();
44139 (arg1)->Check(arg2);
44140 wxPyEndAllowThreads(__tstate);
44141 if (PyErr_Occurred()) SWIG_fail;
44142 }
44143 resultobj = SWIG_Py_Void();
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44151 PyObject *resultobj = 0;
44152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44153 bool result;
44154 void *argp1 = 0 ;
44155 int res1 = 0 ;
44156 PyObject *swig_obj[1] ;
44157
44158 if (!args) SWIG_fail;
44159 swig_obj[0] = args;
44160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44161 if (!SWIG_IsOK(res1)) {
44162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44163 }
44164 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44165 {
44166 PyThreadState* __tstate = wxPyBeginAllowThreads();
44167 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44168 wxPyEndAllowThreads(__tstate);
44169 if (PyErr_Occurred()) SWIG_fail;
44170 }
44171 {
44172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44173 }
44174 return resultobj;
44175 fail:
44176 return NULL;
44177 }
44178
44179
44180 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44181 PyObject *resultobj = 0;
44182 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44183 void *argp1 = 0 ;
44184 int res1 = 0 ;
44185 PyObject *swig_obj[1] ;
44186
44187 if (!args) SWIG_fail;
44188 swig_obj[0] = args;
44189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44190 if (!SWIG_IsOK(res1)) {
44191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44192 }
44193 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44194 {
44195 PyThreadState* __tstate = wxPyBeginAllowThreads();
44196 (arg1)->Toggle();
44197 wxPyEndAllowThreads(__tstate);
44198 if (PyErr_Occurred()) SWIG_fail;
44199 }
44200 resultobj = SWIG_Py_Void();
44201 return resultobj;
44202 fail:
44203 return NULL;
44204 }
44205
44206
44207 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44208 PyObject *resultobj = 0;
44209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44210 wxString *arg2 = 0 ;
44211 void *argp1 = 0 ;
44212 int res1 = 0 ;
44213 bool temp2 = false ;
44214 PyObject * obj0 = 0 ;
44215 PyObject * obj1 = 0 ;
44216 char * kwnames[] = {
44217 (char *) "self",(char *) "str", NULL
44218 };
44219
44220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44222 if (!SWIG_IsOK(res1)) {
44223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44224 }
44225 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44226 {
44227 arg2 = wxString_in_helper(obj1);
44228 if (arg2 == NULL) SWIG_fail;
44229 temp2 = true;
44230 }
44231 {
44232 PyThreadState* __tstate = wxPyBeginAllowThreads();
44233 (arg1)->SetHelp((wxString const &)*arg2);
44234 wxPyEndAllowThreads(__tstate);
44235 if (PyErr_Occurred()) SWIG_fail;
44236 }
44237 resultobj = SWIG_Py_Void();
44238 {
44239 if (temp2)
44240 delete arg2;
44241 }
44242 return resultobj;
44243 fail:
44244 {
44245 if (temp2)
44246 delete arg2;
44247 }
44248 return NULL;
44249 }
44250
44251
44252 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44253 PyObject *resultobj = 0;
44254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44255 wxString *result = 0 ;
44256 void *argp1 = 0 ;
44257 int res1 = 0 ;
44258 PyObject *swig_obj[1] ;
44259
44260 if (!args) SWIG_fail;
44261 swig_obj[0] = args;
44262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44263 if (!SWIG_IsOK(res1)) {
44264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44265 }
44266 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44267 {
44268 PyThreadState* __tstate = wxPyBeginAllowThreads();
44269 {
44270 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44271 result = (wxString *) &_result_ref;
44272 }
44273 wxPyEndAllowThreads(__tstate);
44274 if (PyErr_Occurred()) SWIG_fail;
44275 }
44276 {
44277 #if wxUSE_UNICODE
44278 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44279 #else
44280 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44281 #endif
44282 }
44283 return resultobj;
44284 fail:
44285 return NULL;
44286 }
44287
44288
44289 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44290 PyObject *resultobj = 0;
44291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44292 wxAcceleratorEntry *result = 0 ;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 PyObject *swig_obj[1] ;
44296
44297 if (!args) SWIG_fail;
44298 swig_obj[0] = args;
44299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44300 if (!SWIG_IsOK(res1)) {
44301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44302 }
44303 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44304 {
44305 PyThreadState* __tstate = wxPyBeginAllowThreads();
44306 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44307 wxPyEndAllowThreads(__tstate);
44308 if (PyErr_Occurred()) SWIG_fail;
44309 }
44310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44311 return resultobj;
44312 fail:
44313 return NULL;
44314 }
44315
44316
44317 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44318 PyObject *resultobj = 0;
44319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44320 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44321 void *argp1 = 0 ;
44322 int res1 = 0 ;
44323 void *argp2 = 0 ;
44324 int res2 = 0 ;
44325 PyObject * obj0 = 0 ;
44326 PyObject * obj1 = 0 ;
44327 char * kwnames[] = {
44328 (char *) "self",(char *) "accel", NULL
44329 };
44330
44331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44333 if (!SWIG_IsOK(res1)) {
44334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44335 }
44336 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44338 if (!SWIG_IsOK(res2)) {
44339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44340 }
44341 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44342 {
44343 PyThreadState* __tstate = wxPyBeginAllowThreads();
44344 (arg1)->SetAccel(arg2);
44345 wxPyEndAllowThreads(__tstate);
44346 if (PyErr_Occurred()) SWIG_fail;
44347 }
44348 resultobj = SWIG_Py_Void();
44349 return resultobj;
44350 fail:
44351 return NULL;
44352 }
44353
44354
44355 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44356 PyObject *resultobj = 0;
44357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44358 wxBitmap *arg2 = 0 ;
44359 void *argp1 = 0 ;
44360 int res1 = 0 ;
44361 void *argp2 = 0 ;
44362 int res2 = 0 ;
44363 PyObject * obj0 = 0 ;
44364 PyObject * obj1 = 0 ;
44365 char * kwnames[] = {
44366 (char *) "self",(char *) "bitmap", NULL
44367 };
44368
44369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44371 if (!SWIG_IsOK(res1)) {
44372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44373 }
44374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44375 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44376 if (!SWIG_IsOK(res2)) {
44377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44378 }
44379 if (!argp2) {
44380 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44381 }
44382 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44383 {
44384 PyThreadState* __tstate = wxPyBeginAllowThreads();
44385 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44386 wxPyEndAllowThreads(__tstate);
44387 if (PyErr_Occurred()) SWIG_fail;
44388 }
44389 resultobj = SWIG_Py_Void();
44390 return resultobj;
44391 fail:
44392 return NULL;
44393 }
44394
44395
44396 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44397 PyObject *resultobj = 0;
44398 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44399 wxBitmap *result = 0 ;
44400 void *argp1 = 0 ;
44401 int res1 = 0 ;
44402 PyObject *swig_obj[1] ;
44403
44404 if (!args) SWIG_fail;
44405 swig_obj[0] = args;
44406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44407 if (!SWIG_IsOK(res1)) {
44408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44409 }
44410 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44411 {
44412 PyThreadState* __tstate = wxPyBeginAllowThreads();
44413 {
44414 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44415 result = (wxBitmap *) &_result_ref;
44416 }
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 {
44421 wxBitmap* resultptr = new wxBitmap(*result);
44422 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44423 }
44424 return resultobj;
44425 fail:
44426 return NULL;
44427 }
44428
44429
44430 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44431 PyObject *resultobj = 0;
44432 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44433 wxFont *arg2 = 0 ;
44434 void *argp1 = 0 ;
44435 int res1 = 0 ;
44436 void *argp2 = 0 ;
44437 int res2 = 0 ;
44438 PyObject * obj0 = 0 ;
44439 PyObject * obj1 = 0 ;
44440 char * kwnames[] = {
44441 (char *) "self",(char *) "font", NULL
44442 };
44443
44444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44446 if (!SWIG_IsOK(res1)) {
44447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44448 }
44449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44451 if (!SWIG_IsOK(res2)) {
44452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44453 }
44454 if (!argp2) {
44455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44456 }
44457 arg2 = reinterpret_cast< wxFont * >(argp2);
44458 {
44459 PyThreadState* __tstate = wxPyBeginAllowThreads();
44460 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44461 wxPyEndAllowThreads(__tstate);
44462 if (PyErr_Occurred()) SWIG_fail;
44463 }
44464 resultobj = SWIG_Py_Void();
44465 return resultobj;
44466 fail:
44467 return NULL;
44468 }
44469
44470
44471 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44472 PyObject *resultobj = 0;
44473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44474 wxFont result;
44475 void *argp1 = 0 ;
44476 int res1 = 0 ;
44477 PyObject *swig_obj[1] ;
44478
44479 if (!args) SWIG_fail;
44480 swig_obj[0] = args;
44481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44482 if (!SWIG_IsOK(res1)) {
44483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44484 }
44485 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44486 {
44487 PyThreadState* __tstate = wxPyBeginAllowThreads();
44488 result = wxMenuItem_GetFont(arg1);
44489 wxPyEndAllowThreads(__tstate);
44490 if (PyErr_Occurred()) SWIG_fail;
44491 }
44492 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44493 return resultobj;
44494 fail:
44495 return NULL;
44496 }
44497
44498
44499 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44500 PyObject *resultobj = 0;
44501 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44502 wxColour *arg2 = 0 ;
44503 void *argp1 = 0 ;
44504 int res1 = 0 ;
44505 wxColour temp2 ;
44506 PyObject * obj0 = 0 ;
44507 PyObject * obj1 = 0 ;
44508 char * kwnames[] = {
44509 (char *) "self",(char *) "colText", NULL
44510 };
44511
44512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44514 if (!SWIG_IsOK(res1)) {
44515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44516 }
44517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44518 {
44519 arg2 = &temp2;
44520 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44521 }
44522 {
44523 PyThreadState* __tstate = wxPyBeginAllowThreads();
44524 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 resultobj = SWIG_Py_Void();
44529 return resultobj;
44530 fail:
44531 return NULL;
44532 }
44533
44534
44535 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44536 PyObject *resultobj = 0;
44537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44538 wxColour result;
44539 void *argp1 = 0 ;
44540 int res1 = 0 ;
44541 PyObject *swig_obj[1] ;
44542
44543 if (!args) SWIG_fail;
44544 swig_obj[0] = args;
44545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44546 if (!SWIG_IsOK(res1)) {
44547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44548 }
44549 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44550 {
44551 PyThreadState* __tstate = wxPyBeginAllowThreads();
44552 result = wxMenuItem_GetTextColour(arg1);
44553 wxPyEndAllowThreads(__tstate);
44554 if (PyErr_Occurred()) SWIG_fail;
44555 }
44556 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44557 return resultobj;
44558 fail:
44559 return NULL;
44560 }
44561
44562
44563 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44564 PyObject *resultobj = 0;
44565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44566 wxColour *arg2 = 0 ;
44567 void *argp1 = 0 ;
44568 int res1 = 0 ;
44569 wxColour temp2 ;
44570 PyObject * obj0 = 0 ;
44571 PyObject * obj1 = 0 ;
44572 char * kwnames[] = {
44573 (char *) "self",(char *) "colBack", NULL
44574 };
44575
44576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44578 if (!SWIG_IsOK(res1)) {
44579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44580 }
44581 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44582 {
44583 arg2 = &temp2;
44584 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44585 }
44586 {
44587 PyThreadState* __tstate = wxPyBeginAllowThreads();
44588 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 resultobj = SWIG_Py_Void();
44593 return resultobj;
44594 fail:
44595 return NULL;
44596 }
44597
44598
44599 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44600 PyObject *resultobj = 0;
44601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44602 wxColour result;
44603 void *argp1 = 0 ;
44604 int res1 = 0 ;
44605 PyObject *swig_obj[1] ;
44606
44607 if (!args) SWIG_fail;
44608 swig_obj[0] = args;
44609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44610 if (!SWIG_IsOK(res1)) {
44611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44612 }
44613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44614 {
44615 PyThreadState* __tstate = wxPyBeginAllowThreads();
44616 result = wxMenuItem_GetBackgroundColour(arg1);
44617 wxPyEndAllowThreads(__tstate);
44618 if (PyErr_Occurred()) SWIG_fail;
44619 }
44620 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44621 return resultobj;
44622 fail:
44623 return NULL;
44624 }
44625
44626
44627 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44628 PyObject *resultobj = 0;
44629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44630 wxBitmap *arg2 = 0 ;
44631 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44632 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44633 void *argp1 = 0 ;
44634 int res1 = 0 ;
44635 void *argp2 = 0 ;
44636 int res2 = 0 ;
44637 void *argp3 = 0 ;
44638 int res3 = 0 ;
44639 PyObject * obj0 = 0 ;
44640 PyObject * obj1 = 0 ;
44641 PyObject * obj2 = 0 ;
44642 char * kwnames[] = {
44643 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44644 };
44645
44646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44648 if (!SWIG_IsOK(res1)) {
44649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44650 }
44651 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44653 if (!SWIG_IsOK(res2)) {
44654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44655 }
44656 if (!argp2) {
44657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44658 }
44659 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44660 if (obj2) {
44661 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44662 if (!SWIG_IsOK(res3)) {
44663 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44664 }
44665 if (!argp3) {
44666 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44667 }
44668 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44669 }
44670 {
44671 PyThreadState* __tstate = wxPyBeginAllowThreads();
44672 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44673 wxPyEndAllowThreads(__tstate);
44674 if (PyErr_Occurred()) SWIG_fail;
44675 }
44676 resultobj = SWIG_Py_Void();
44677 return resultobj;
44678 fail:
44679 return NULL;
44680 }
44681
44682
44683 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44684 PyObject *resultobj = 0;
44685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44686 wxBitmap *arg2 = 0 ;
44687 void *argp1 = 0 ;
44688 int res1 = 0 ;
44689 void *argp2 = 0 ;
44690 int res2 = 0 ;
44691 PyObject * obj0 = 0 ;
44692 PyObject * obj1 = 0 ;
44693 char * kwnames[] = {
44694 (char *) "self",(char *) "bmpDisabled", NULL
44695 };
44696
44697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44699 if (!SWIG_IsOK(res1)) {
44700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44701 }
44702 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44703 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44704 if (!SWIG_IsOK(res2)) {
44705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44706 }
44707 if (!argp2) {
44708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44709 }
44710 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44711 {
44712 PyThreadState* __tstate = wxPyBeginAllowThreads();
44713 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44714 wxPyEndAllowThreads(__tstate);
44715 if (PyErr_Occurred()) SWIG_fail;
44716 }
44717 resultobj = SWIG_Py_Void();
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44725 PyObject *resultobj = 0;
44726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44727 wxBitmap *result = 0 ;
44728 void *argp1 = 0 ;
44729 int res1 = 0 ;
44730 PyObject *swig_obj[1] ;
44731
44732 if (!args) SWIG_fail;
44733 swig_obj[0] = args;
44734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44735 if (!SWIG_IsOK(res1)) {
44736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44737 }
44738 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44739 {
44740 PyThreadState* __tstate = wxPyBeginAllowThreads();
44741 {
44742 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44743 result = (wxBitmap *) &_result_ref;
44744 }
44745 wxPyEndAllowThreads(__tstate);
44746 if (PyErr_Occurred()) SWIG_fail;
44747 }
44748 {
44749 wxBitmap* resultptr = new wxBitmap(*result);
44750 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44751 }
44752 return resultobj;
44753 fail:
44754 return NULL;
44755 }
44756
44757
44758 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44759 PyObject *resultobj = 0;
44760 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44761 int arg2 ;
44762 void *argp1 = 0 ;
44763 int res1 = 0 ;
44764 int val2 ;
44765 int ecode2 = 0 ;
44766 PyObject * obj0 = 0 ;
44767 PyObject * obj1 = 0 ;
44768 char * kwnames[] = {
44769 (char *) "self",(char *) "nWidth", NULL
44770 };
44771
44772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44774 if (!SWIG_IsOK(res1)) {
44775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44776 }
44777 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44778 ecode2 = SWIG_AsVal_int(obj1, &val2);
44779 if (!SWIG_IsOK(ecode2)) {
44780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44781 }
44782 arg2 = static_cast< int >(val2);
44783 {
44784 PyThreadState* __tstate = wxPyBeginAllowThreads();
44785 wxMenuItem_SetMarginWidth(arg1,arg2);
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 resultobj = SWIG_Py_Void();
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44797 PyObject *resultobj = 0;
44798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44799 int result;
44800 void *argp1 = 0 ;
44801 int res1 = 0 ;
44802 PyObject *swig_obj[1] ;
44803
44804 if (!args) SWIG_fail;
44805 swig_obj[0] = args;
44806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44807 if (!SWIG_IsOK(res1)) {
44808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44809 }
44810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44811 {
44812 PyThreadState* __tstate = wxPyBeginAllowThreads();
44813 result = (int)wxMenuItem_GetMarginWidth(arg1);
44814 wxPyEndAllowThreads(__tstate);
44815 if (PyErr_Occurred()) SWIG_fail;
44816 }
44817 resultobj = SWIG_From_int(static_cast< int >(result));
44818 return resultobj;
44819 fail:
44820 return NULL;
44821 }
44822
44823
44824 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44825 PyObject *resultobj = 0;
44826 int result;
44827
44828 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44829 {
44830 PyThreadState* __tstate = wxPyBeginAllowThreads();
44831 result = (int)wxMenuItem_GetDefaultMarginWidth();
44832 wxPyEndAllowThreads(__tstate);
44833 if (PyErr_Occurred()) SWIG_fail;
44834 }
44835 resultobj = SWIG_From_int(static_cast< int >(result));
44836 return resultobj;
44837 fail:
44838 return NULL;
44839 }
44840
44841
44842 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44843 PyObject *resultobj = 0;
44844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44845 bool result;
44846 void *argp1 = 0 ;
44847 int res1 = 0 ;
44848 PyObject *swig_obj[1] ;
44849
44850 if (!args) SWIG_fail;
44851 swig_obj[0] = args;
44852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44853 if (!SWIG_IsOK(res1)) {
44854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44855 }
44856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44857 {
44858 PyThreadState* __tstate = wxPyBeginAllowThreads();
44859 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44860 wxPyEndAllowThreads(__tstate);
44861 if (PyErr_Occurred()) SWIG_fail;
44862 }
44863 {
44864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44865 }
44866 return resultobj;
44867 fail:
44868 return NULL;
44869 }
44870
44871
44872 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44873 PyObject *resultobj = 0;
44874 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44875 bool arg2 = (bool) true ;
44876 void *argp1 = 0 ;
44877 int res1 = 0 ;
44878 bool val2 ;
44879 int ecode2 = 0 ;
44880 PyObject * obj0 = 0 ;
44881 PyObject * obj1 = 0 ;
44882 char * kwnames[] = {
44883 (char *) "self",(char *) "ownerDrawn", NULL
44884 };
44885
44886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44888 if (!SWIG_IsOK(res1)) {
44889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44890 }
44891 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44892 if (obj1) {
44893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44894 if (!SWIG_IsOK(ecode2)) {
44895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44896 }
44897 arg2 = static_cast< bool >(val2);
44898 }
44899 {
44900 PyThreadState* __tstate = wxPyBeginAllowThreads();
44901 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44902 wxPyEndAllowThreads(__tstate);
44903 if (PyErr_Occurred()) SWIG_fail;
44904 }
44905 resultobj = SWIG_Py_Void();
44906 return resultobj;
44907 fail:
44908 return NULL;
44909 }
44910
44911
44912 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44913 PyObject *resultobj = 0;
44914 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44915 void *argp1 = 0 ;
44916 int res1 = 0 ;
44917 PyObject *swig_obj[1] ;
44918
44919 if (!args) SWIG_fail;
44920 swig_obj[0] = args;
44921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44922 if (!SWIG_IsOK(res1)) {
44923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44924 }
44925 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44926 {
44927 PyThreadState* __tstate = wxPyBeginAllowThreads();
44928 wxMenuItem_ResetOwnerDrawn(arg1);
44929 wxPyEndAllowThreads(__tstate);
44930 if (PyErr_Occurred()) SWIG_fail;
44931 }
44932 resultobj = SWIG_Py_Void();
44933 return resultobj;
44934 fail:
44935 return NULL;
44936 }
44937
44938
44939 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44940 PyObject *obj;
44941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44942 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44943 return SWIG_Py_Void();
44944 }
44945
44946 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44947 return SWIG_Python_InitShadowInstance(args);
44948 }
44949
44950 SWIGINTERN int ControlNameStr_set(PyObject *) {
44951 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44952 return 1;
44953 }
44954
44955
44956 SWIGINTERN PyObject *ControlNameStr_get(void) {
44957 PyObject *pyobj = 0;
44958
44959 {
44960 #if wxUSE_UNICODE
44961 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44962 #else
44963 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44964 #endif
44965 }
44966 return pyobj;
44967 }
44968
44969
44970 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44971 PyObject *resultobj = 0;
44972 wxWindow *arg1 = (wxWindow *) 0 ;
44973 int arg2 = (int) -1 ;
44974 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44975 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44976 wxSize const &arg4_defvalue = wxDefaultSize ;
44977 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44978 long arg5 = (long) 0 ;
44979 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44980 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44981 wxString const &arg7_defvalue = wxPyControlNameStr ;
44982 wxString *arg7 = (wxString *) &arg7_defvalue ;
44983 wxControl *result = 0 ;
44984 void *argp1 = 0 ;
44985 int res1 = 0 ;
44986 int val2 ;
44987 int ecode2 = 0 ;
44988 wxPoint temp3 ;
44989 wxSize temp4 ;
44990 long val5 ;
44991 int ecode5 = 0 ;
44992 void *argp6 = 0 ;
44993 int res6 = 0 ;
44994 bool temp7 = false ;
44995 PyObject * obj0 = 0 ;
44996 PyObject * obj1 = 0 ;
44997 PyObject * obj2 = 0 ;
44998 PyObject * obj3 = 0 ;
44999 PyObject * obj4 = 0 ;
45000 PyObject * obj5 = 0 ;
45001 PyObject * obj6 = 0 ;
45002 char * kwnames[] = {
45003 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45004 };
45005
45006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45008 if (!SWIG_IsOK(res1)) {
45009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45010 }
45011 arg1 = reinterpret_cast< wxWindow * >(argp1);
45012 if (obj1) {
45013 ecode2 = SWIG_AsVal_int(obj1, &val2);
45014 if (!SWIG_IsOK(ecode2)) {
45015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45016 }
45017 arg2 = static_cast< int >(val2);
45018 }
45019 if (obj2) {
45020 {
45021 arg3 = &temp3;
45022 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45023 }
45024 }
45025 if (obj3) {
45026 {
45027 arg4 = &temp4;
45028 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45029 }
45030 }
45031 if (obj4) {
45032 ecode5 = SWIG_AsVal_long(obj4, &val5);
45033 if (!SWIG_IsOK(ecode5)) {
45034 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45035 }
45036 arg5 = static_cast< long >(val5);
45037 }
45038 if (obj5) {
45039 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45040 if (!SWIG_IsOK(res6)) {
45041 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45042 }
45043 if (!argp6) {
45044 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45045 }
45046 arg6 = reinterpret_cast< wxValidator * >(argp6);
45047 }
45048 if (obj6) {
45049 {
45050 arg7 = wxString_in_helper(obj6);
45051 if (arg7 == NULL) SWIG_fail;
45052 temp7 = true;
45053 }
45054 }
45055 {
45056 if (!wxPyCheckForApp()) SWIG_fail;
45057 PyThreadState* __tstate = wxPyBeginAllowThreads();
45058 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45059 wxPyEndAllowThreads(__tstate);
45060 if (PyErr_Occurred()) SWIG_fail;
45061 }
45062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45063 {
45064 if (temp7)
45065 delete arg7;
45066 }
45067 return resultobj;
45068 fail:
45069 {
45070 if (temp7)
45071 delete arg7;
45072 }
45073 return NULL;
45074 }
45075
45076
45077 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45078 PyObject *resultobj = 0;
45079 wxControl *result = 0 ;
45080
45081 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45082 {
45083 if (!wxPyCheckForApp()) SWIG_fail;
45084 PyThreadState* __tstate = wxPyBeginAllowThreads();
45085 result = (wxControl *)new wxControl();
45086 wxPyEndAllowThreads(__tstate);
45087 if (PyErr_Occurred()) SWIG_fail;
45088 }
45089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45090 return resultobj;
45091 fail:
45092 return NULL;
45093 }
45094
45095
45096 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45097 PyObject *resultobj = 0;
45098 wxControl *arg1 = (wxControl *) 0 ;
45099 wxWindow *arg2 = (wxWindow *) 0 ;
45100 int arg3 = (int) -1 ;
45101 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45102 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45103 wxSize const &arg5_defvalue = wxDefaultSize ;
45104 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45105 long arg6 = (long) 0 ;
45106 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45107 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45108 wxString const &arg8_defvalue = wxPyControlNameStr ;
45109 wxString *arg8 = (wxString *) &arg8_defvalue ;
45110 bool result;
45111 void *argp1 = 0 ;
45112 int res1 = 0 ;
45113 void *argp2 = 0 ;
45114 int res2 = 0 ;
45115 int val3 ;
45116 int ecode3 = 0 ;
45117 wxPoint temp4 ;
45118 wxSize temp5 ;
45119 long val6 ;
45120 int ecode6 = 0 ;
45121 void *argp7 = 0 ;
45122 int res7 = 0 ;
45123 bool temp8 = false ;
45124 PyObject * obj0 = 0 ;
45125 PyObject * obj1 = 0 ;
45126 PyObject * obj2 = 0 ;
45127 PyObject * obj3 = 0 ;
45128 PyObject * obj4 = 0 ;
45129 PyObject * obj5 = 0 ;
45130 PyObject * obj6 = 0 ;
45131 PyObject * obj7 = 0 ;
45132 char * kwnames[] = {
45133 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45134 };
45135
45136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45138 if (!SWIG_IsOK(res1)) {
45139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45140 }
45141 arg1 = reinterpret_cast< wxControl * >(argp1);
45142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45143 if (!SWIG_IsOK(res2)) {
45144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45145 }
45146 arg2 = reinterpret_cast< wxWindow * >(argp2);
45147 if (obj2) {
45148 ecode3 = SWIG_AsVal_int(obj2, &val3);
45149 if (!SWIG_IsOK(ecode3)) {
45150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45151 }
45152 arg3 = static_cast< int >(val3);
45153 }
45154 if (obj3) {
45155 {
45156 arg4 = &temp4;
45157 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45158 }
45159 }
45160 if (obj4) {
45161 {
45162 arg5 = &temp5;
45163 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45164 }
45165 }
45166 if (obj5) {
45167 ecode6 = SWIG_AsVal_long(obj5, &val6);
45168 if (!SWIG_IsOK(ecode6)) {
45169 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45170 }
45171 arg6 = static_cast< long >(val6);
45172 }
45173 if (obj6) {
45174 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45175 if (!SWIG_IsOK(res7)) {
45176 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45177 }
45178 if (!argp7) {
45179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45180 }
45181 arg7 = reinterpret_cast< wxValidator * >(argp7);
45182 }
45183 if (obj7) {
45184 {
45185 arg8 = wxString_in_helper(obj7);
45186 if (arg8 == NULL) SWIG_fail;
45187 temp8 = true;
45188 }
45189 }
45190 {
45191 PyThreadState* __tstate = wxPyBeginAllowThreads();
45192 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45193 wxPyEndAllowThreads(__tstate);
45194 if (PyErr_Occurred()) SWIG_fail;
45195 }
45196 {
45197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45198 }
45199 {
45200 if (temp8)
45201 delete arg8;
45202 }
45203 return resultobj;
45204 fail:
45205 {
45206 if (temp8)
45207 delete arg8;
45208 }
45209 return NULL;
45210 }
45211
45212
45213 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45214 PyObject *resultobj = 0;
45215 wxControl *arg1 = (wxControl *) 0 ;
45216 int result;
45217 void *argp1 = 0 ;
45218 int res1 = 0 ;
45219 PyObject *swig_obj[1] ;
45220
45221 if (!args) SWIG_fail;
45222 swig_obj[0] = args;
45223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45226 }
45227 arg1 = reinterpret_cast< wxControl * >(argp1);
45228 {
45229 PyThreadState* __tstate = wxPyBeginAllowThreads();
45230 result = (int)((wxControl const *)arg1)->GetAlignment();
45231 wxPyEndAllowThreads(__tstate);
45232 if (PyErr_Occurred()) SWIG_fail;
45233 }
45234 resultobj = SWIG_From_int(static_cast< int >(result));
45235 return resultobj;
45236 fail:
45237 return NULL;
45238 }
45239
45240
45241 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45242 PyObject *resultobj = 0;
45243 wxControl *arg1 = (wxControl *) 0 ;
45244 wxString result;
45245 void *argp1 = 0 ;
45246 int res1 = 0 ;
45247 PyObject *swig_obj[1] ;
45248
45249 if (!args) SWIG_fail;
45250 swig_obj[0] = args;
45251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45252 if (!SWIG_IsOK(res1)) {
45253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45254 }
45255 arg1 = reinterpret_cast< wxControl * >(argp1);
45256 {
45257 PyThreadState* __tstate = wxPyBeginAllowThreads();
45258 result = ((wxControl const *)arg1)->GetLabelText();
45259 wxPyEndAllowThreads(__tstate);
45260 if (PyErr_Occurred()) SWIG_fail;
45261 }
45262 {
45263 #if wxUSE_UNICODE
45264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45265 #else
45266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45267 #endif
45268 }
45269 return resultobj;
45270 fail:
45271 return NULL;
45272 }
45273
45274
45275 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45276 PyObject *resultobj = 0;
45277 wxControl *arg1 = (wxControl *) 0 ;
45278 wxCommandEvent *arg2 = 0 ;
45279 void *argp1 = 0 ;
45280 int res1 = 0 ;
45281 void *argp2 = 0 ;
45282 int res2 = 0 ;
45283 PyObject * obj0 = 0 ;
45284 PyObject * obj1 = 0 ;
45285 char * kwnames[] = {
45286 (char *) "self",(char *) "event", NULL
45287 };
45288
45289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45291 if (!SWIG_IsOK(res1)) {
45292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45293 }
45294 arg1 = reinterpret_cast< wxControl * >(argp1);
45295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45296 if (!SWIG_IsOK(res2)) {
45297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45298 }
45299 if (!argp2) {
45300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45301 }
45302 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45303 {
45304 PyThreadState* __tstate = wxPyBeginAllowThreads();
45305 (arg1)->Command(*arg2);
45306 wxPyEndAllowThreads(__tstate);
45307 if (PyErr_Occurred()) SWIG_fail;
45308 }
45309 resultobj = SWIG_Py_Void();
45310 return resultobj;
45311 fail:
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj = 0;
45318 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45319 SwigValueWrapper<wxVisualAttributes > result;
45320 int val1 ;
45321 int ecode1 = 0 ;
45322 PyObject * obj0 = 0 ;
45323 char * kwnames[] = {
45324 (char *) "variant", NULL
45325 };
45326
45327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45328 if (obj0) {
45329 ecode1 = SWIG_AsVal_int(obj0, &val1);
45330 if (!SWIG_IsOK(ecode1)) {
45331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45332 }
45333 arg1 = static_cast< wxWindowVariant >(val1);
45334 }
45335 {
45336 if (!wxPyCheckForApp()) SWIG_fail;
45337 PyThreadState* __tstate = wxPyBeginAllowThreads();
45338 result = wxControl::GetClassDefaultAttributes(arg1);
45339 wxPyEndAllowThreads(__tstate);
45340 if (PyErr_Occurred()) SWIG_fail;
45341 }
45342 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45343 return resultobj;
45344 fail:
45345 return NULL;
45346 }
45347
45348
45349 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45350 PyObject *obj;
45351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45352 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45353 return SWIG_Py_Void();
45354 }
45355
45356 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45357 return SWIG_Python_InitShadowInstance(args);
45358 }
45359
45360 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45361 PyObject *resultobj = 0;
45362 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45363 wxString *arg2 = 0 ;
45364 PyObject *arg3 = (PyObject *) NULL ;
45365 int result;
45366 void *argp1 = 0 ;
45367 int res1 = 0 ;
45368 bool temp2 = false ;
45369 PyObject * obj0 = 0 ;
45370 PyObject * obj1 = 0 ;
45371 PyObject * obj2 = 0 ;
45372 char * kwnames[] = {
45373 (char *) "self",(char *) "item",(char *) "clientData", NULL
45374 };
45375
45376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45378 if (!SWIG_IsOK(res1)) {
45379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45380 }
45381 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45382 {
45383 arg2 = wxString_in_helper(obj1);
45384 if (arg2 == NULL) SWIG_fail;
45385 temp2 = true;
45386 }
45387 if (obj2) {
45388 arg3 = obj2;
45389 }
45390 {
45391 PyThreadState* __tstate = wxPyBeginAllowThreads();
45392 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45393 wxPyEndAllowThreads(__tstate);
45394 if (PyErr_Occurred()) SWIG_fail;
45395 }
45396 resultobj = SWIG_From_int(static_cast< int >(result));
45397 {
45398 if (temp2)
45399 delete arg2;
45400 }
45401 return resultobj;
45402 fail:
45403 {
45404 if (temp2)
45405 delete arg2;
45406 }
45407 return NULL;
45408 }
45409
45410
45411 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45412 PyObject *resultobj = 0;
45413 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45414 wxArrayString *arg2 = 0 ;
45415 void *argp1 = 0 ;
45416 int res1 = 0 ;
45417 bool temp2 = false ;
45418 PyObject * obj0 = 0 ;
45419 PyObject * obj1 = 0 ;
45420 char * kwnames[] = {
45421 (char *) "self",(char *) "strings", NULL
45422 };
45423
45424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45426 if (!SWIG_IsOK(res1)) {
45427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45428 }
45429 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45430 {
45431 if (! PySequence_Check(obj1)) {
45432 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45433 SWIG_fail;
45434 }
45435 arg2 = new wxArrayString;
45436 temp2 = true;
45437 int i, len=PySequence_Length(obj1);
45438 for (i=0; i<len; i++) {
45439 PyObject* item = PySequence_GetItem(obj1, i);
45440 wxString* s = wxString_in_helper(item);
45441 if (PyErr_Occurred()) SWIG_fail;
45442 arg2->Add(*s);
45443 delete s;
45444 Py_DECREF(item);
45445 }
45446 }
45447 {
45448 PyThreadState* __tstate = wxPyBeginAllowThreads();
45449 (arg1)->Append((wxArrayString const &)*arg2);
45450 wxPyEndAllowThreads(__tstate);
45451 if (PyErr_Occurred()) SWIG_fail;
45452 }
45453 resultobj = SWIG_Py_Void();
45454 {
45455 if (temp2) delete arg2;
45456 }
45457 return resultobj;
45458 fail:
45459 {
45460 if (temp2) delete arg2;
45461 }
45462 return NULL;
45463 }
45464
45465
45466 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45467 PyObject *resultobj = 0;
45468 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45469 wxString *arg2 = 0 ;
45470 unsigned int arg3 ;
45471 PyObject *arg4 = (PyObject *) NULL ;
45472 int result;
45473 void *argp1 = 0 ;
45474 int res1 = 0 ;
45475 bool temp2 = false ;
45476 unsigned int val3 ;
45477 int ecode3 = 0 ;
45478 PyObject * obj0 = 0 ;
45479 PyObject * obj1 = 0 ;
45480 PyObject * obj2 = 0 ;
45481 PyObject * obj3 = 0 ;
45482 char * kwnames[] = {
45483 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45484 };
45485
45486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45488 if (!SWIG_IsOK(res1)) {
45489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45490 }
45491 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45492 {
45493 arg2 = wxString_in_helper(obj1);
45494 if (arg2 == NULL) SWIG_fail;
45495 temp2 = true;
45496 }
45497 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45498 if (!SWIG_IsOK(ecode3)) {
45499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45500 }
45501 arg3 = static_cast< unsigned int >(val3);
45502 if (obj3) {
45503 arg4 = obj3;
45504 }
45505 {
45506 PyThreadState* __tstate = wxPyBeginAllowThreads();
45507 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45508 wxPyEndAllowThreads(__tstate);
45509 if (PyErr_Occurred()) SWIG_fail;
45510 }
45511 resultobj = SWIG_From_int(static_cast< int >(result));
45512 {
45513 if (temp2)
45514 delete arg2;
45515 }
45516 return resultobj;
45517 fail:
45518 {
45519 if (temp2)
45520 delete arg2;
45521 }
45522 return NULL;
45523 }
45524
45525
45526 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45527 PyObject *resultobj = 0;
45528 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45529 void *argp1 = 0 ;
45530 int res1 = 0 ;
45531 PyObject *swig_obj[1] ;
45532
45533 if (!args) SWIG_fail;
45534 swig_obj[0] = args;
45535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45536 if (!SWIG_IsOK(res1)) {
45537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45538 }
45539 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 (arg1)->Clear();
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 resultobj = SWIG_Py_Void();
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45554 PyObject *resultobj = 0;
45555 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45556 unsigned int arg2 ;
45557 void *argp1 = 0 ;
45558 int res1 = 0 ;
45559 unsigned int val2 ;
45560 int ecode2 = 0 ;
45561 PyObject * obj0 = 0 ;
45562 PyObject * obj1 = 0 ;
45563 char * kwnames[] = {
45564 (char *) "self",(char *) "n", NULL
45565 };
45566
45567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45569 if (!SWIG_IsOK(res1)) {
45570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45571 }
45572 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45573 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45574 if (!SWIG_IsOK(ecode2)) {
45575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45576 }
45577 arg2 = static_cast< unsigned int >(val2);
45578 {
45579 PyThreadState* __tstate = wxPyBeginAllowThreads();
45580 (arg1)->Delete(arg2);
45581 wxPyEndAllowThreads(__tstate);
45582 if (PyErr_Occurred()) SWIG_fail;
45583 }
45584 resultobj = SWIG_Py_Void();
45585 return resultobj;
45586 fail:
45587 return NULL;
45588 }
45589
45590
45591 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45592 PyObject *resultobj = 0;
45593 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45594 unsigned int arg2 ;
45595 PyObject *result = 0 ;
45596 void *argp1 = 0 ;
45597 int res1 = 0 ;
45598 unsigned int val2 ;
45599 int ecode2 = 0 ;
45600 PyObject * obj0 = 0 ;
45601 PyObject * obj1 = 0 ;
45602 char * kwnames[] = {
45603 (char *) "self",(char *) "n", NULL
45604 };
45605
45606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45608 if (!SWIG_IsOK(res1)) {
45609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45610 }
45611 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45612 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45613 if (!SWIG_IsOK(ecode2)) {
45614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45615 }
45616 arg2 = static_cast< unsigned int >(val2);
45617 {
45618 PyThreadState* __tstate = wxPyBeginAllowThreads();
45619 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45620 wxPyEndAllowThreads(__tstate);
45621 if (PyErr_Occurred()) SWIG_fail;
45622 }
45623 resultobj = result;
45624 return resultobj;
45625 fail:
45626 return NULL;
45627 }
45628
45629
45630 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45631 PyObject *resultobj = 0;
45632 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45633 unsigned int arg2 ;
45634 PyObject *arg3 = (PyObject *) 0 ;
45635 void *argp1 = 0 ;
45636 int res1 = 0 ;
45637 unsigned int val2 ;
45638 int ecode2 = 0 ;
45639 PyObject * obj0 = 0 ;
45640 PyObject * obj1 = 0 ;
45641 PyObject * obj2 = 0 ;
45642 char * kwnames[] = {
45643 (char *) "self",(char *) "n",(char *) "clientData", NULL
45644 };
45645
45646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) 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_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45650 }
45651 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45652 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45653 if (!SWIG_IsOK(ecode2)) {
45654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45655 }
45656 arg2 = static_cast< unsigned int >(val2);
45657 arg3 = obj2;
45658 {
45659 PyThreadState* __tstate = wxPyBeginAllowThreads();
45660 wxItemContainer_SetClientData(arg1,arg2,arg3);
45661 wxPyEndAllowThreads(__tstate);
45662 if (PyErr_Occurred()) SWIG_fail;
45663 }
45664 resultobj = SWIG_Py_Void();
45665 return resultobj;
45666 fail:
45667 return NULL;
45668 }
45669
45670
45671 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45672 PyObject *resultobj = 0;
45673 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45674 unsigned int result;
45675 void *argp1 = 0 ;
45676 int res1 = 0 ;
45677 PyObject *swig_obj[1] ;
45678
45679 if (!args) SWIG_fail;
45680 swig_obj[0] = args;
45681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45682 if (!SWIG_IsOK(res1)) {
45683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45684 }
45685 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45686 {
45687 PyThreadState* __tstate = wxPyBeginAllowThreads();
45688 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45689 wxPyEndAllowThreads(__tstate);
45690 if (PyErr_Occurred()) SWIG_fail;
45691 }
45692 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45693 return resultobj;
45694 fail:
45695 return NULL;
45696 }
45697
45698
45699 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45700 PyObject *resultobj = 0;
45701 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45702 bool result;
45703 void *argp1 = 0 ;
45704 int res1 = 0 ;
45705 PyObject *swig_obj[1] ;
45706
45707 if (!args) SWIG_fail;
45708 swig_obj[0] = args;
45709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45710 if (!SWIG_IsOK(res1)) {
45711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45712 }
45713 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45714 {
45715 PyThreadState* __tstate = wxPyBeginAllowThreads();
45716 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45717 wxPyEndAllowThreads(__tstate);
45718 if (PyErr_Occurred()) SWIG_fail;
45719 }
45720 {
45721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45722 }
45723 return resultobj;
45724 fail:
45725 return NULL;
45726 }
45727
45728
45729 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45730 PyObject *resultobj = 0;
45731 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45732 unsigned int arg2 ;
45733 wxString result;
45734 void *argp1 = 0 ;
45735 int res1 = 0 ;
45736 unsigned int val2 ;
45737 int ecode2 = 0 ;
45738 PyObject * obj0 = 0 ;
45739 PyObject * obj1 = 0 ;
45740 char * kwnames[] = {
45741 (char *) "self",(char *) "n", NULL
45742 };
45743
45744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45746 if (!SWIG_IsOK(res1)) {
45747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45748 }
45749 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45750 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45751 if (!SWIG_IsOK(ecode2)) {
45752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45753 }
45754 arg2 = static_cast< unsigned int >(val2);
45755 {
45756 PyThreadState* __tstate = wxPyBeginAllowThreads();
45757 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45758 wxPyEndAllowThreads(__tstate);
45759 if (PyErr_Occurred()) SWIG_fail;
45760 }
45761 {
45762 #if wxUSE_UNICODE
45763 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45764 #else
45765 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45766 #endif
45767 }
45768 return resultobj;
45769 fail:
45770 return NULL;
45771 }
45772
45773
45774 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45775 PyObject *resultobj = 0;
45776 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45777 wxArrayString result;
45778 void *argp1 = 0 ;
45779 int res1 = 0 ;
45780 PyObject *swig_obj[1] ;
45781
45782 if (!args) SWIG_fail;
45783 swig_obj[0] = args;
45784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45785 if (!SWIG_IsOK(res1)) {
45786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45787 }
45788 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45789 {
45790 PyThreadState* __tstate = wxPyBeginAllowThreads();
45791 result = ((wxItemContainer const *)arg1)->GetStrings();
45792 wxPyEndAllowThreads(__tstate);
45793 if (PyErr_Occurred()) SWIG_fail;
45794 }
45795 {
45796 resultobj = wxArrayString2PyList_helper(result);
45797 }
45798 return resultobj;
45799 fail:
45800 return NULL;
45801 }
45802
45803
45804 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45805 PyObject *resultobj = 0;
45806 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45807 unsigned int arg2 ;
45808 wxString *arg3 = 0 ;
45809 void *argp1 = 0 ;
45810 int res1 = 0 ;
45811 unsigned int val2 ;
45812 int ecode2 = 0 ;
45813 bool temp3 = false ;
45814 PyObject * obj0 = 0 ;
45815 PyObject * obj1 = 0 ;
45816 PyObject * obj2 = 0 ;
45817 char * kwnames[] = {
45818 (char *) "self",(char *) "n",(char *) "s", NULL
45819 };
45820
45821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45823 if (!SWIG_IsOK(res1)) {
45824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45825 }
45826 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45827 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45828 if (!SWIG_IsOK(ecode2)) {
45829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45830 }
45831 arg2 = static_cast< unsigned int >(val2);
45832 {
45833 arg3 = wxString_in_helper(obj2);
45834 if (arg3 == NULL) SWIG_fail;
45835 temp3 = true;
45836 }
45837 {
45838 PyThreadState* __tstate = wxPyBeginAllowThreads();
45839 (arg1)->SetString(arg2,(wxString const &)*arg3);
45840 wxPyEndAllowThreads(__tstate);
45841 if (PyErr_Occurred()) SWIG_fail;
45842 }
45843 resultobj = SWIG_Py_Void();
45844 {
45845 if (temp3)
45846 delete arg3;
45847 }
45848 return resultobj;
45849 fail:
45850 {
45851 if (temp3)
45852 delete arg3;
45853 }
45854 return NULL;
45855 }
45856
45857
45858 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45859 PyObject *resultobj = 0;
45860 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45861 wxString *arg2 = 0 ;
45862 int result;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 bool temp2 = false ;
45866 PyObject * obj0 = 0 ;
45867 PyObject * obj1 = 0 ;
45868 char * kwnames[] = {
45869 (char *) "self",(char *) "s", NULL
45870 };
45871
45872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45874 if (!SWIG_IsOK(res1)) {
45875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45876 }
45877 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45878 {
45879 arg2 = wxString_in_helper(obj1);
45880 if (arg2 == NULL) SWIG_fail;
45881 temp2 = true;
45882 }
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 resultobj = SWIG_From_int(static_cast< int >(result));
45890 {
45891 if (temp2)
45892 delete arg2;
45893 }
45894 return resultobj;
45895 fail:
45896 {
45897 if (temp2)
45898 delete arg2;
45899 }
45900 return NULL;
45901 }
45902
45903
45904 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45905 PyObject *resultobj = 0;
45906 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45907 int arg2 ;
45908 void *argp1 = 0 ;
45909 int res1 = 0 ;
45910 int val2 ;
45911 int ecode2 = 0 ;
45912 PyObject * obj0 = 0 ;
45913 PyObject * obj1 = 0 ;
45914 char * kwnames[] = {
45915 (char *) "self",(char *) "n", NULL
45916 };
45917
45918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45920 if (!SWIG_IsOK(res1)) {
45921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45922 }
45923 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45924 ecode2 = SWIG_AsVal_int(obj1, &val2);
45925 if (!SWIG_IsOK(ecode2)) {
45926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45927 }
45928 arg2 = static_cast< int >(val2);
45929 {
45930 PyThreadState* __tstate = wxPyBeginAllowThreads();
45931 (arg1)->SetSelection(arg2);
45932 wxPyEndAllowThreads(__tstate);
45933 if (PyErr_Occurred()) SWIG_fail;
45934 }
45935 resultobj = SWIG_Py_Void();
45936 return resultobj;
45937 fail:
45938 return NULL;
45939 }
45940
45941
45942 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45943 PyObject *resultobj = 0;
45944 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45945 int result;
45946 void *argp1 = 0 ;
45947 int res1 = 0 ;
45948 PyObject *swig_obj[1] ;
45949
45950 if (!args) SWIG_fail;
45951 swig_obj[0] = args;
45952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45953 if (!SWIG_IsOK(res1)) {
45954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45955 }
45956 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45957 {
45958 PyThreadState* __tstate = wxPyBeginAllowThreads();
45959 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45960 wxPyEndAllowThreads(__tstate);
45961 if (PyErr_Occurred()) SWIG_fail;
45962 }
45963 resultobj = SWIG_From_int(static_cast< int >(result));
45964 return resultobj;
45965 fail:
45966 return NULL;
45967 }
45968
45969
45970 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45971 PyObject *resultobj = 0;
45972 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45973 wxString *arg2 = 0 ;
45974 bool result;
45975 void *argp1 = 0 ;
45976 int res1 = 0 ;
45977 bool temp2 = false ;
45978 PyObject * obj0 = 0 ;
45979 PyObject * obj1 = 0 ;
45980 char * kwnames[] = {
45981 (char *) "self",(char *) "s", NULL
45982 };
45983
45984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45986 if (!SWIG_IsOK(res1)) {
45987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45988 }
45989 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45990 {
45991 arg2 = wxString_in_helper(obj1);
45992 if (arg2 == NULL) SWIG_fail;
45993 temp2 = true;
45994 }
45995 {
45996 PyThreadState* __tstate = wxPyBeginAllowThreads();
45997 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45998 wxPyEndAllowThreads(__tstate);
45999 if (PyErr_Occurred()) SWIG_fail;
46000 }
46001 {
46002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46003 }
46004 {
46005 if (temp2)
46006 delete arg2;
46007 }
46008 return resultobj;
46009 fail:
46010 {
46011 if (temp2)
46012 delete arg2;
46013 }
46014 return NULL;
46015 }
46016
46017
46018 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46019 PyObject *resultobj = 0;
46020 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46021 wxString result;
46022 void *argp1 = 0 ;
46023 int res1 = 0 ;
46024 PyObject *swig_obj[1] ;
46025
46026 if (!args) SWIG_fail;
46027 swig_obj[0] = args;
46028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46029 if (!SWIG_IsOK(res1)) {
46030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46031 }
46032 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46033 {
46034 PyThreadState* __tstate = wxPyBeginAllowThreads();
46035 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46036 wxPyEndAllowThreads(__tstate);
46037 if (PyErr_Occurred()) SWIG_fail;
46038 }
46039 {
46040 #if wxUSE_UNICODE
46041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46042 #else
46043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46044 #endif
46045 }
46046 return resultobj;
46047 fail:
46048 return NULL;
46049 }
46050
46051
46052 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46053 PyObject *resultobj = 0;
46054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46055 int arg2 ;
46056 void *argp1 = 0 ;
46057 int res1 = 0 ;
46058 int val2 ;
46059 int ecode2 = 0 ;
46060 PyObject * obj0 = 0 ;
46061 PyObject * obj1 = 0 ;
46062 char * kwnames[] = {
46063 (char *) "self",(char *) "n", NULL
46064 };
46065
46066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46068 if (!SWIG_IsOK(res1)) {
46069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46070 }
46071 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46072 ecode2 = SWIG_AsVal_int(obj1, &val2);
46073 if (!SWIG_IsOK(ecode2)) {
46074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46075 }
46076 arg2 = static_cast< int >(val2);
46077 {
46078 PyThreadState* __tstate = wxPyBeginAllowThreads();
46079 (arg1)->Select(arg2);
46080 wxPyEndAllowThreads(__tstate);
46081 if (PyErr_Occurred()) SWIG_fail;
46082 }
46083 resultobj = SWIG_Py_Void();
46084 return resultobj;
46085 fail:
46086 return NULL;
46087 }
46088
46089
46090 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46091 PyObject *obj;
46092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46093 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46094 return SWIG_Py_Void();
46095 }
46096
46097 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46098 PyObject *obj;
46099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46100 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46101 return SWIG_Py_Void();
46102 }
46103
46104 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46105 PyObject *resultobj = 0;
46106 wxSizerItem *result = 0 ;
46107
46108 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 result = (wxSizerItem *)new wxSizerItem();
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46123 PyObject *resultobj = 0;
46124 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 PyObject *swig_obj[1] ;
46128
46129 if (!args) SWIG_fail;
46130 swig_obj[0] = args;
46131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46134 }
46135 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46136 {
46137 PyThreadState* __tstate = wxPyBeginAllowThreads();
46138 delete arg1;
46139
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_Py_Void();
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxWindow *arg1 = (wxWindow *) 0 ;
46153 int arg2 ;
46154 int arg3 ;
46155 int arg4 ;
46156 PyObject *arg5 = (PyObject *) NULL ;
46157 wxSizerItem *result = 0 ;
46158 void *argp1 = 0 ;
46159 int res1 = 0 ;
46160 int val2 ;
46161 int ecode2 = 0 ;
46162 int val3 ;
46163 int ecode3 = 0 ;
46164 int val4 ;
46165 int ecode4 = 0 ;
46166 PyObject * obj0 = 0 ;
46167 PyObject * obj1 = 0 ;
46168 PyObject * obj2 = 0 ;
46169 PyObject * obj3 = 0 ;
46170 PyObject * obj4 = 0 ;
46171 char * kwnames[] = {
46172 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46173 };
46174
46175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46177 if (!SWIG_IsOK(res1)) {
46178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46179 }
46180 arg1 = reinterpret_cast< wxWindow * >(argp1);
46181 ecode2 = SWIG_AsVal_int(obj1, &val2);
46182 if (!SWIG_IsOK(ecode2)) {
46183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46184 }
46185 arg2 = static_cast< int >(val2);
46186 ecode3 = SWIG_AsVal_int(obj2, &val3);
46187 if (!SWIG_IsOK(ecode3)) {
46188 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46189 }
46190 arg3 = static_cast< int >(val3);
46191 ecode4 = SWIG_AsVal_int(obj3, &val4);
46192 if (!SWIG_IsOK(ecode4)) {
46193 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46194 }
46195 arg4 = static_cast< int >(val4);
46196 if (obj4) {
46197 arg5 = obj4;
46198 }
46199 {
46200 PyThreadState* __tstate = wxPyBeginAllowThreads();
46201 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46202 wxPyEndAllowThreads(__tstate);
46203 if (PyErr_Occurred()) SWIG_fail;
46204 }
46205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46206 return resultobj;
46207 fail:
46208 return NULL;
46209 }
46210
46211
46212 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46213 PyObject *resultobj = 0;
46214 int arg1 ;
46215 int arg2 ;
46216 int arg3 ;
46217 int arg4 ;
46218 int arg5 ;
46219 PyObject *arg6 = (PyObject *) NULL ;
46220 wxSizerItem *result = 0 ;
46221 int val1 ;
46222 int ecode1 = 0 ;
46223 int val2 ;
46224 int ecode2 = 0 ;
46225 int val3 ;
46226 int ecode3 = 0 ;
46227 int val4 ;
46228 int ecode4 = 0 ;
46229 int val5 ;
46230 int ecode5 = 0 ;
46231 PyObject * obj0 = 0 ;
46232 PyObject * obj1 = 0 ;
46233 PyObject * obj2 = 0 ;
46234 PyObject * obj3 = 0 ;
46235 PyObject * obj4 = 0 ;
46236 PyObject * obj5 = 0 ;
46237 char * kwnames[] = {
46238 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46239 };
46240
46241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46242 ecode1 = SWIG_AsVal_int(obj0, &val1);
46243 if (!SWIG_IsOK(ecode1)) {
46244 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46245 }
46246 arg1 = static_cast< int >(val1);
46247 ecode2 = SWIG_AsVal_int(obj1, &val2);
46248 if (!SWIG_IsOK(ecode2)) {
46249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46250 }
46251 arg2 = static_cast< int >(val2);
46252 ecode3 = SWIG_AsVal_int(obj2, &val3);
46253 if (!SWIG_IsOK(ecode3)) {
46254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46255 }
46256 arg3 = static_cast< int >(val3);
46257 ecode4 = SWIG_AsVal_int(obj3, &val4);
46258 if (!SWIG_IsOK(ecode4)) {
46259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46260 }
46261 arg4 = static_cast< int >(val4);
46262 ecode5 = SWIG_AsVal_int(obj4, &val5);
46263 if (!SWIG_IsOK(ecode5)) {
46264 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46265 }
46266 arg5 = static_cast< int >(val5);
46267 if (obj5) {
46268 arg6 = obj5;
46269 }
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46284 PyObject *resultobj = 0;
46285 wxSizer *arg1 = (wxSizer *) 0 ;
46286 int arg2 ;
46287 int arg3 ;
46288 int arg4 ;
46289 PyObject *arg5 = (PyObject *) NULL ;
46290 wxSizerItem *result = 0 ;
46291 int res1 = 0 ;
46292 int val2 ;
46293 int ecode2 = 0 ;
46294 int val3 ;
46295 int ecode3 = 0 ;
46296 int val4 ;
46297 int ecode4 = 0 ;
46298 PyObject * obj0 = 0 ;
46299 PyObject * obj1 = 0 ;
46300 PyObject * obj2 = 0 ;
46301 PyObject * obj3 = 0 ;
46302 PyObject * obj4 = 0 ;
46303 char * kwnames[] = {
46304 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46305 };
46306
46307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46308 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46309 if (!SWIG_IsOK(res1)) {
46310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46311 }
46312 ecode2 = SWIG_AsVal_int(obj1, &val2);
46313 if (!SWIG_IsOK(ecode2)) {
46314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46315 }
46316 arg2 = static_cast< int >(val2);
46317 ecode3 = SWIG_AsVal_int(obj2, &val3);
46318 if (!SWIG_IsOK(ecode3)) {
46319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46320 }
46321 arg3 = static_cast< int >(val3);
46322 ecode4 = SWIG_AsVal_int(obj3, &val4);
46323 if (!SWIG_IsOK(ecode4)) {
46324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46325 }
46326 arg4 = static_cast< int >(val4);
46327 if (obj4) {
46328 arg5 = obj4;
46329 }
46330 {
46331 PyThreadState* __tstate = wxPyBeginAllowThreads();
46332 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46333 wxPyEndAllowThreads(__tstate);
46334 if (PyErr_Occurred()) SWIG_fail;
46335 }
46336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46337 return resultobj;
46338 fail:
46339 return NULL;
46340 }
46341
46342
46343 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46344 PyObject *resultobj = 0;
46345 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46346 void *argp1 = 0 ;
46347 int res1 = 0 ;
46348 PyObject *swig_obj[1] ;
46349
46350 if (!args) SWIG_fail;
46351 swig_obj[0] = args;
46352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46353 if (!SWIG_IsOK(res1)) {
46354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46355 }
46356 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46357 {
46358 PyThreadState* __tstate = wxPyBeginAllowThreads();
46359 (arg1)->DeleteWindows();
46360 wxPyEndAllowThreads(__tstate);
46361 if (PyErr_Occurred()) SWIG_fail;
46362 }
46363 resultobj = SWIG_Py_Void();
46364 return resultobj;
46365 fail:
46366 return NULL;
46367 }
46368
46369
46370 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46371 PyObject *resultobj = 0;
46372 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46373 void *argp1 = 0 ;
46374 int res1 = 0 ;
46375 PyObject *swig_obj[1] ;
46376
46377 if (!args) SWIG_fail;
46378 swig_obj[0] = args;
46379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46380 if (!SWIG_IsOK(res1)) {
46381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46382 }
46383 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46384 {
46385 PyThreadState* __tstate = wxPyBeginAllowThreads();
46386 (arg1)->DetachSizer();
46387 wxPyEndAllowThreads(__tstate);
46388 if (PyErr_Occurred()) SWIG_fail;
46389 }
46390 resultobj = SWIG_Py_Void();
46391 return resultobj;
46392 fail:
46393 return NULL;
46394 }
46395
46396
46397 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46398 PyObject *resultobj = 0;
46399 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46400 wxSize result;
46401 void *argp1 = 0 ;
46402 int res1 = 0 ;
46403 PyObject *swig_obj[1] ;
46404
46405 if (!args) SWIG_fail;
46406 swig_obj[0] = args;
46407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46408 if (!SWIG_IsOK(res1)) {
46409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46410 }
46411 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46412 {
46413 PyThreadState* __tstate = wxPyBeginAllowThreads();
46414 result = (arg1)->GetSize();
46415 wxPyEndAllowThreads(__tstate);
46416 if (PyErr_Occurred()) SWIG_fail;
46417 }
46418 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46419 return resultobj;
46420 fail:
46421 return NULL;
46422 }
46423
46424
46425 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46426 PyObject *resultobj = 0;
46427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46428 wxSize result;
46429 void *argp1 = 0 ;
46430 int res1 = 0 ;
46431 PyObject *swig_obj[1] ;
46432
46433 if (!args) SWIG_fail;
46434 swig_obj[0] = args;
46435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46436 if (!SWIG_IsOK(res1)) {
46437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46438 }
46439 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46440 {
46441 PyThreadState* __tstate = wxPyBeginAllowThreads();
46442 result = (arg1)->CalcMin();
46443 wxPyEndAllowThreads(__tstate);
46444 if (PyErr_Occurred()) SWIG_fail;
46445 }
46446 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46447 return resultobj;
46448 fail:
46449 return NULL;
46450 }
46451
46452
46453 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46454 PyObject *resultobj = 0;
46455 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46456 wxPoint *arg2 = 0 ;
46457 wxSize *arg3 = 0 ;
46458 void *argp1 = 0 ;
46459 int res1 = 0 ;
46460 wxPoint temp2 ;
46461 wxSize temp3 ;
46462 PyObject * obj0 = 0 ;
46463 PyObject * obj1 = 0 ;
46464 PyObject * obj2 = 0 ;
46465 char * kwnames[] = {
46466 (char *) "self",(char *) "pos",(char *) "size", NULL
46467 };
46468
46469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46471 if (!SWIG_IsOK(res1)) {
46472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46473 }
46474 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46475 {
46476 arg2 = &temp2;
46477 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46478 }
46479 {
46480 arg3 = &temp3;
46481 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46482 }
46483 {
46484 PyThreadState* __tstate = wxPyBeginAllowThreads();
46485 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46486 wxPyEndAllowThreads(__tstate);
46487 if (PyErr_Occurred()) SWIG_fail;
46488 }
46489 resultobj = SWIG_Py_Void();
46490 return resultobj;
46491 fail:
46492 return NULL;
46493 }
46494
46495
46496 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46497 PyObject *resultobj = 0;
46498 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46499 wxSize result;
46500 void *argp1 = 0 ;
46501 int res1 = 0 ;
46502 PyObject *swig_obj[1] ;
46503
46504 if (!args) SWIG_fail;
46505 swig_obj[0] = args;
46506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46507 if (!SWIG_IsOK(res1)) {
46508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46509 }
46510 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46511 {
46512 PyThreadState* __tstate = wxPyBeginAllowThreads();
46513 result = (arg1)->GetMinSize();
46514 wxPyEndAllowThreads(__tstate);
46515 if (PyErr_Occurred()) SWIG_fail;
46516 }
46517 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46518 return resultobj;
46519 fail:
46520 return NULL;
46521 }
46522
46523
46524 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46525 PyObject *resultobj = 0;
46526 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46527 wxSize result;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 PyObject *swig_obj[1] ;
46531
46532 if (!args) SWIG_fail;
46533 swig_obj[0] = args;
46534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46535 if (!SWIG_IsOK(res1)) {
46536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46537 }
46538 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46539 {
46540 PyThreadState* __tstate = wxPyBeginAllowThreads();
46541 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46542 wxPyEndAllowThreads(__tstate);
46543 if (PyErr_Occurred()) SWIG_fail;
46544 }
46545 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46546 return resultobj;
46547 fail:
46548 return NULL;
46549 }
46550
46551
46552 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46553 PyObject *resultobj = 0;
46554 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46555 int arg2 ;
46556 int arg3 ;
46557 void *argp1 = 0 ;
46558 int res1 = 0 ;
46559 int val2 ;
46560 int ecode2 = 0 ;
46561 int val3 ;
46562 int ecode3 = 0 ;
46563 PyObject * obj0 = 0 ;
46564 PyObject * obj1 = 0 ;
46565 PyObject * obj2 = 0 ;
46566 char * kwnames[] = {
46567 (char *) "self",(char *) "x",(char *) "y", NULL
46568 };
46569
46570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46572 if (!SWIG_IsOK(res1)) {
46573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46574 }
46575 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46576 ecode2 = SWIG_AsVal_int(obj1, &val2);
46577 if (!SWIG_IsOK(ecode2)) {
46578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46579 }
46580 arg2 = static_cast< int >(val2);
46581 ecode3 = SWIG_AsVal_int(obj2, &val3);
46582 if (!SWIG_IsOK(ecode3)) {
46583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46584 }
46585 arg3 = static_cast< int >(val3);
46586 {
46587 PyThreadState* __tstate = wxPyBeginAllowThreads();
46588 (arg1)->SetInitSize(arg2,arg3);
46589 wxPyEndAllowThreads(__tstate);
46590 if (PyErr_Occurred()) SWIG_fail;
46591 }
46592 resultobj = SWIG_Py_Void();
46593 return resultobj;
46594 fail:
46595 return NULL;
46596 }
46597
46598
46599 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46600 PyObject *resultobj = 0;
46601 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46602 int arg2 ;
46603 int arg3 ;
46604 void *argp1 = 0 ;
46605 int res1 = 0 ;
46606 int val2 ;
46607 int ecode2 = 0 ;
46608 int val3 ;
46609 int ecode3 = 0 ;
46610 PyObject * obj0 = 0 ;
46611 PyObject * obj1 = 0 ;
46612 PyObject * obj2 = 0 ;
46613 char * kwnames[] = {
46614 (char *) "self",(char *) "width",(char *) "height", NULL
46615 };
46616
46617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46619 if (!SWIG_IsOK(res1)) {
46620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46621 }
46622 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46623 ecode2 = SWIG_AsVal_int(obj1, &val2);
46624 if (!SWIG_IsOK(ecode2)) {
46625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46626 }
46627 arg2 = static_cast< int >(val2);
46628 ecode3 = SWIG_AsVal_int(obj2, &val3);
46629 if (!SWIG_IsOK(ecode3)) {
46630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46631 }
46632 arg3 = static_cast< int >(val3);
46633 {
46634 PyThreadState* __tstate = wxPyBeginAllowThreads();
46635 (arg1)->SetRatio(arg2,arg3);
46636 wxPyEndAllowThreads(__tstate);
46637 if (PyErr_Occurred()) SWIG_fail;
46638 }
46639 resultobj = SWIG_Py_Void();
46640 return resultobj;
46641 fail:
46642 return NULL;
46643 }
46644
46645
46646 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46647 PyObject *resultobj = 0;
46648 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46649 wxSize *arg2 = 0 ;
46650 void *argp1 = 0 ;
46651 int res1 = 0 ;
46652 wxSize temp2 ;
46653 PyObject * obj0 = 0 ;
46654 PyObject * obj1 = 0 ;
46655 char * kwnames[] = {
46656 (char *) "self",(char *) "size", NULL
46657 };
46658
46659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46661 if (!SWIG_IsOK(res1)) {
46662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46663 }
46664 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46665 {
46666 arg2 = &temp2;
46667 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46668 }
46669 {
46670 PyThreadState* __tstate = wxPyBeginAllowThreads();
46671 (arg1)->SetRatio((wxSize const &)*arg2);
46672 wxPyEndAllowThreads(__tstate);
46673 if (PyErr_Occurred()) SWIG_fail;
46674 }
46675 resultobj = SWIG_Py_Void();
46676 return resultobj;
46677 fail:
46678 return NULL;
46679 }
46680
46681
46682 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46683 PyObject *resultobj = 0;
46684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46685 float arg2 ;
46686 void *argp1 = 0 ;
46687 int res1 = 0 ;
46688 float val2 ;
46689 int ecode2 = 0 ;
46690 PyObject * obj0 = 0 ;
46691 PyObject * obj1 = 0 ;
46692 char * kwnames[] = {
46693 (char *) "self",(char *) "ratio", NULL
46694 };
46695
46696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46698 if (!SWIG_IsOK(res1)) {
46699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46700 }
46701 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46702 ecode2 = SWIG_AsVal_float(obj1, &val2);
46703 if (!SWIG_IsOK(ecode2)) {
46704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46705 }
46706 arg2 = static_cast< float >(val2);
46707 {
46708 PyThreadState* __tstate = wxPyBeginAllowThreads();
46709 (arg1)->SetRatio(arg2);
46710 wxPyEndAllowThreads(__tstate);
46711 if (PyErr_Occurred()) SWIG_fail;
46712 }
46713 resultobj = SWIG_Py_Void();
46714 return resultobj;
46715 fail:
46716 return NULL;
46717 }
46718
46719
46720 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46721 PyObject *resultobj = 0;
46722 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46723 float result;
46724 void *argp1 = 0 ;
46725 int res1 = 0 ;
46726 PyObject *swig_obj[1] ;
46727
46728 if (!args) SWIG_fail;
46729 swig_obj[0] = args;
46730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46731 if (!SWIG_IsOK(res1)) {
46732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46733 }
46734 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46735 {
46736 PyThreadState* __tstate = wxPyBeginAllowThreads();
46737 result = (float)(arg1)->GetRatio();
46738 wxPyEndAllowThreads(__tstate);
46739 if (PyErr_Occurred()) SWIG_fail;
46740 }
46741 resultobj = SWIG_From_float(static_cast< float >(result));
46742 return resultobj;
46743 fail:
46744 return NULL;
46745 }
46746
46747
46748 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46749 PyObject *resultobj = 0;
46750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46751 wxRect result;
46752 void *argp1 = 0 ;
46753 int res1 = 0 ;
46754 PyObject *swig_obj[1] ;
46755
46756 if (!args) SWIG_fail;
46757 swig_obj[0] = args;
46758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46759 if (!SWIG_IsOK(res1)) {
46760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46761 }
46762 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46763 {
46764 PyThreadState* __tstate = wxPyBeginAllowThreads();
46765 result = (arg1)->GetRect();
46766 wxPyEndAllowThreads(__tstate);
46767 if (PyErr_Occurred()) SWIG_fail;
46768 }
46769 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46770 return resultobj;
46771 fail:
46772 return NULL;
46773 }
46774
46775
46776 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46777 PyObject *resultobj = 0;
46778 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46779 bool result;
46780 void *argp1 = 0 ;
46781 int res1 = 0 ;
46782 PyObject *swig_obj[1] ;
46783
46784 if (!args) SWIG_fail;
46785 swig_obj[0] = args;
46786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46789 }
46790 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46791 {
46792 PyThreadState* __tstate = wxPyBeginAllowThreads();
46793 result = (bool)(arg1)->IsWindow();
46794 wxPyEndAllowThreads(__tstate);
46795 if (PyErr_Occurred()) SWIG_fail;
46796 }
46797 {
46798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46799 }
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46807 PyObject *resultobj = 0;
46808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46809 bool result;
46810 void *argp1 = 0 ;
46811 int res1 = 0 ;
46812 PyObject *swig_obj[1] ;
46813
46814 if (!args) SWIG_fail;
46815 swig_obj[0] = args;
46816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46817 if (!SWIG_IsOK(res1)) {
46818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46819 }
46820 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46821 {
46822 PyThreadState* __tstate = wxPyBeginAllowThreads();
46823 result = (bool)(arg1)->IsSizer();
46824 wxPyEndAllowThreads(__tstate);
46825 if (PyErr_Occurred()) SWIG_fail;
46826 }
46827 {
46828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46829 }
46830 return resultobj;
46831 fail:
46832 return NULL;
46833 }
46834
46835
46836 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46837 PyObject *resultobj = 0;
46838 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46839 bool result;
46840 void *argp1 = 0 ;
46841 int res1 = 0 ;
46842 PyObject *swig_obj[1] ;
46843
46844 if (!args) SWIG_fail;
46845 swig_obj[0] = args;
46846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46847 if (!SWIG_IsOK(res1)) {
46848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46849 }
46850 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46851 {
46852 PyThreadState* __tstate = wxPyBeginAllowThreads();
46853 result = (bool)(arg1)->IsSpacer();
46854 wxPyEndAllowThreads(__tstate);
46855 if (PyErr_Occurred()) SWIG_fail;
46856 }
46857 {
46858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46859 }
46860 return resultobj;
46861 fail:
46862 return NULL;
46863 }
46864
46865
46866 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46867 PyObject *resultobj = 0;
46868 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46869 int arg2 ;
46870 void *argp1 = 0 ;
46871 int res1 = 0 ;
46872 int val2 ;
46873 int ecode2 = 0 ;
46874 PyObject * obj0 = 0 ;
46875 PyObject * obj1 = 0 ;
46876 char * kwnames[] = {
46877 (char *) "self",(char *) "proportion", NULL
46878 };
46879
46880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46882 if (!SWIG_IsOK(res1)) {
46883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46884 }
46885 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46886 ecode2 = SWIG_AsVal_int(obj1, &val2);
46887 if (!SWIG_IsOK(ecode2)) {
46888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46889 }
46890 arg2 = static_cast< int >(val2);
46891 {
46892 PyThreadState* __tstate = wxPyBeginAllowThreads();
46893 (arg1)->SetProportion(arg2);
46894 wxPyEndAllowThreads(__tstate);
46895 if (PyErr_Occurred()) SWIG_fail;
46896 }
46897 resultobj = SWIG_Py_Void();
46898 return resultobj;
46899 fail:
46900 return NULL;
46901 }
46902
46903
46904 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46905 PyObject *resultobj = 0;
46906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46907 int result;
46908 void *argp1 = 0 ;
46909 int res1 = 0 ;
46910 PyObject *swig_obj[1] ;
46911
46912 if (!args) SWIG_fail;
46913 swig_obj[0] = args;
46914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46915 if (!SWIG_IsOK(res1)) {
46916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46917 }
46918 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46919 {
46920 PyThreadState* __tstate = wxPyBeginAllowThreads();
46921 result = (int)(arg1)->GetProportion();
46922 wxPyEndAllowThreads(__tstate);
46923 if (PyErr_Occurred()) SWIG_fail;
46924 }
46925 resultobj = SWIG_From_int(static_cast< int >(result));
46926 return resultobj;
46927 fail:
46928 return NULL;
46929 }
46930
46931
46932 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46933 PyObject *resultobj = 0;
46934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46935 int arg2 ;
46936 void *argp1 = 0 ;
46937 int res1 = 0 ;
46938 int val2 ;
46939 int ecode2 = 0 ;
46940 PyObject * obj0 = 0 ;
46941 PyObject * obj1 = 0 ;
46942 char * kwnames[] = {
46943 (char *) "self",(char *) "flag", NULL
46944 };
46945
46946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46948 if (!SWIG_IsOK(res1)) {
46949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46950 }
46951 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46952 ecode2 = SWIG_AsVal_int(obj1, &val2);
46953 if (!SWIG_IsOK(ecode2)) {
46954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46955 }
46956 arg2 = static_cast< int >(val2);
46957 {
46958 PyThreadState* __tstate = wxPyBeginAllowThreads();
46959 (arg1)->SetFlag(arg2);
46960 wxPyEndAllowThreads(__tstate);
46961 if (PyErr_Occurred()) SWIG_fail;
46962 }
46963 resultobj = SWIG_Py_Void();
46964 return resultobj;
46965 fail:
46966 return NULL;
46967 }
46968
46969
46970 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46971 PyObject *resultobj = 0;
46972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46973 int result;
46974 void *argp1 = 0 ;
46975 int res1 = 0 ;
46976 PyObject *swig_obj[1] ;
46977
46978 if (!args) SWIG_fail;
46979 swig_obj[0] = args;
46980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46981 if (!SWIG_IsOK(res1)) {
46982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46983 }
46984 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46985 {
46986 PyThreadState* __tstate = wxPyBeginAllowThreads();
46987 result = (int)(arg1)->GetFlag();
46988 wxPyEndAllowThreads(__tstate);
46989 if (PyErr_Occurred()) SWIG_fail;
46990 }
46991 resultobj = SWIG_From_int(static_cast< int >(result));
46992 return resultobj;
46993 fail:
46994 return NULL;
46995 }
46996
46997
46998 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46999 PyObject *resultobj = 0;
47000 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47001 int arg2 ;
47002 void *argp1 = 0 ;
47003 int res1 = 0 ;
47004 int val2 ;
47005 int ecode2 = 0 ;
47006 PyObject * obj0 = 0 ;
47007 PyObject * obj1 = 0 ;
47008 char * kwnames[] = {
47009 (char *) "self",(char *) "border", NULL
47010 };
47011
47012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47014 if (!SWIG_IsOK(res1)) {
47015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47016 }
47017 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47018 ecode2 = SWIG_AsVal_int(obj1, &val2);
47019 if (!SWIG_IsOK(ecode2)) {
47020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47021 }
47022 arg2 = static_cast< int >(val2);
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 (arg1)->SetBorder(arg2);
47026 wxPyEndAllowThreads(__tstate);
47027 if (PyErr_Occurred()) SWIG_fail;
47028 }
47029 resultobj = SWIG_Py_Void();
47030 return resultobj;
47031 fail:
47032 return NULL;
47033 }
47034
47035
47036 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47037 PyObject *resultobj = 0;
47038 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47039 int result;
47040 void *argp1 = 0 ;
47041 int res1 = 0 ;
47042 PyObject *swig_obj[1] ;
47043
47044 if (!args) SWIG_fail;
47045 swig_obj[0] = args;
47046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47047 if (!SWIG_IsOK(res1)) {
47048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47049 }
47050 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47051 {
47052 PyThreadState* __tstate = wxPyBeginAllowThreads();
47053 result = (int)(arg1)->GetBorder();
47054 wxPyEndAllowThreads(__tstate);
47055 if (PyErr_Occurred()) SWIG_fail;
47056 }
47057 resultobj = SWIG_From_int(static_cast< int >(result));
47058 return resultobj;
47059 fail:
47060 return NULL;
47061 }
47062
47063
47064 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47065 PyObject *resultobj = 0;
47066 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47067 wxWindow *result = 0 ;
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_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47077 }
47078 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47079 {
47080 PyThreadState* __tstate = wxPyBeginAllowThreads();
47081 result = (wxWindow *)(arg1)->GetWindow();
47082 wxPyEndAllowThreads(__tstate);
47083 if (PyErr_Occurred()) SWIG_fail;
47084 }
47085 {
47086 resultobj = wxPyMake_wxObject(result, 0);
47087 }
47088 return resultobj;
47089 fail:
47090 return NULL;
47091 }
47092
47093
47094 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47095 PyObject *resultobj = 0;
47096 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47097 wxWindow *arg2 = (wxWindow *) 0 ;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 void *argp2 = 0 ;
47101 int res2 = 0 ;
47102 PyObject * obj0 = 0 ;
47103 PyObject * obj1 = 0 ;
47104 char * kwnames[] = {
47105 (char *) "self",(char *) "window", NULL
47106 };
47107
47108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47110 if (!SWIG_IsOK(res1)) {
47111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47112 }
47113 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47115 if (!SWIG_IsOK(res2)) {
47116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47117 }
47118 arg2 = reinterpret_cast< wxWindow * >(argp2);
47119 {
47120 PyThreadState* __tstate = wxPyBeginAllowThreads();
47121 (arg1)->SetWindow(arg2);
47122 wxPyEndAllowThreads(__tstate);
47123 if (PyErr_Occurred()) SWIG_fail;
47124 }
47125 resultobj = SWIG_Py_Void();
47126 return resultobj;
47127 fail:
47128 return NULL;
47129 }
47130
47131
47132 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47133 PyObject *resultobj = 0;
47134 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47135 wxSizer *result = 0 ;
47136 void *argp1 = 0 ;
47137 int res1 = 0 ;
47138 PyObject *swig_obj[1] ;
47139
47140 if (!args) SWIG_fail;
47141 swig_obj[0] = args;
47142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47143 if (!SWIG_IsOK(res1)) {
47144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47145 }
47146 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47147 {
47148 PyThreadState* __tstate = wxPyBeginAllowThreads();
47149 result = (wxSizer *)(arg1)->GetSizer();
47150 wxPyEndAllowThreads(__tstate);
47151 if (PyErr_Occurred()) SWIG_fail;
47152 }
47153 {
47154 resultobj = wxPyMake_wxObject(result, (bool)0);
47155 }
47156 return resultobj;
47157 fail:
47158 return NULL;
47159 }
47160
47161
47162 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47163 PyObject *resultobj = 0;
47164 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47165 wxSizer *arg2 = (wxSizer *) 0 ;
47166 void *argp1 = 0 ;
47167 int res1 = 0 ;
47168 int res2 = 0 ;
47169 PyObject * obj0 = 0 ;
47170 PyObject * obj1 = 0 ;
47171 char * kwnames[] = {
47172 (char *) "self",(char *) "sizer", NULL
47173 };
47174
47175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47177 if (!SWIG_IsOK(res1)) {
47178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47179 }
47180 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47181 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47182 if (!SWIG_IsOK(res2)) {
47183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47184 }
47185 {
47186 PyThreadState* __tstate = wxPyBeginAllowThreads();
47187 (arg1)->SetSizer(arg2);
47188 wxPyEndAllowThreads(__tstate);
47189 if (PyErr_Occurred()) SWIG_fail;
47190 }
47191 resultobj = SWIG_Py_Void();
47192 return resultobj;
47193 fail:
47194 return NULL;
47195 }
47196
47197
47198 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47199 PyObject *resultobj = 0;
47200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47201 wxSize *result = 0 ;
47202 void *argp1 = 0 ;
47203 int res1 = 0 ;
47204 PyObject *swig_obj[1] ;
47205
47206 if (!args) SWIG_fail;
47207 swig_obj[0] = args;
47208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47209 if (!SWIG_IsOK(res1)) {
47210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47211 }
47212 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47213 {
47214 PyThreadState* __tstate = wxPyBeginAllowThreads();
47215 {
47216 wxSize const &_result_ref = (arg1)->GetSpacer();
47217 result = (wxSize *) &_result_ref;
47218 }
47219 wxPyEndAllowThreads(__tstate);
47220 if (PyErr_Occurred()) SWIG_fail;
47221 }
47222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
47223 return resultobj;
47224 fail:
47225 return NULL;
47226 }
47227
47228
47229 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47230 PyObject *resultobj = 0;
47231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47232 wxSize *arg2 = 0 ;
47233 void *argp1 = 0 ;
47234 int res1 = 0 ;
47235 wxSize temp2 ;
47236 PyObject * obj0 = 0 ;
47237 PyObject * obj1 = 0 ;
47238 char * kwnames[] = {
47239 (char *) "self",(char *) "size", NULL
47240 };
47241
47242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47244 if (!SWIG_IsOK(res1)) {
47245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47246 }
47247 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47248 {
47249 arg2 = &temp2;
47250 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47251 }
47252 {
47253 PyThreadState* __tstate = wxPyBeginAllowThreads();
47254 (arg1)->SetSpacer((wxSize const &)*arg2);
47255 wxPyEndAllowThreads(__tstate);
47256 if (PyErr_Occurred()) SWIG_fail;
47257 }
47258 resultobj = SWIG_Py_Void();
47259 return resultobj;
47260 fail:
47261 return NULL;
47262 }
47263
47264
47265 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47266 PyObject *resultobj = 0;
47267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47268 bool arg2 ;
47269 void *argp1 = 0 ;
47270 int res1 = 0 ;
47271 bool val2 ;
47272 int ecode2 = 0 ;
47273 PyObject * obj0 = 0 ;
47274 PyObject * obj1 = 0 ;
47275 char * kwnames[] = {
47276 (char *) "self",(char *) "show", NULL
47277 };
47278
47279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47281 if (!SWIG_IsOK(res1)) {
47282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47283 }
47284 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47285 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47286 if (!SWIG_IsOK(ecode2)) {
47287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47288 }
47289 arg2 = static_cast< bool >(val2);
47290 {
47291 PyThreadState* __tstate = wxPyBeginAllowThreads();
47292 (arg1)->Show(arg2);
47293 wxPyEndAllowThreads(__tstate);
47294 if (PyErr_Occurred()) SWIG_fail;
47295 }
47296 resultobj = SWIG_Py_Void();
47297 return resultobj;
47298 fail:
47299 return NULL;
47300 }
47301
47302
47303 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47304 PyObject *resultobj = 0;
47305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47306 bool result;
47307 void *argp1 = 0 ;
47308 int res1 = 0 ;
47309 PyObject *swig_obj[1] ;
47310
47311 if (!args) SWIG_fail;
47312 swig_obj[0] = args;
47313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47314 if (!SWIG_IsOK(res1)) {
47315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47316 }
47317 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47318 {
47319 PyThreadState* __tstate = wxPyBeginAllowThreads();
47320 result = (bool)(arg1)->IsShown();
47321 wxPyEndAllowThreads(__tstate);
47322 if (PyErr_Occurred()) SWIG_fail;
47323 }
47324 {
47325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47326 }
47327 return resultobj;
47328 fail:
47329 return NULL;
47330 }
47331
47332
47333 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47334 PyObject *resultobj = 0;
47335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47336 wxPoint result;
47337 void *argp1 = 0 ;
47338 int res1 = 0 ;
47339 PyObject *swig_obj[1] ;
47340
47341 if (!args) SWIG_fail;
47342 swig_obj[0] = args;
47343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47344 if (!SWIG_IsOK(res1)) {
47345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47346 }
47347 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47348 {
47349 PyThreadState* __tstate = wxPyBeginAllowThreads();
47350 result = (arg1)->GetPosition();
47351 wxPyEndAllowThreads(__tstate);
47352 if (PyErr_Occurred()) SWIG_fail;
47353 }
47354 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47355 return resultobj;
47356 fail:
47357 return NULL;
47358 }
47359
47360
47361 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47362 PyObject *resultobj = 0;
47363 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47364 PyObject *result = 0 ;
47365 void *argp1 = 0 ;
47366 int res1 = 0 ;
47367 PyObject *swig_obj[1] ;
47368
47369 if (!args) SWIG_fail;
47370 swig_obj[0] = args;
47371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47372 if (!SWIG_IsOK(res1)) {
47373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47374 }
47375 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47376 {
47377 PyThreadState* __tstate = wxPyBeginAllowThreads();
47378 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47379 wxPyEndAllowThreads(__tstate);
47380 if (PyErr_Occurred()) SWIG_fail;
47381 }
47382 resultobj = result;
47383 return resultobj;
47384 fail:
47385 return NULL;
47386 }
47387
47388
47389 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47390 PyObject *resultobj = 0;
47391 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47392 PyObject *arg2 = (PyObject *) 0 ;
47393 void *argp1 = 0 ;
47394 int res1 = 0 ;
47395 PyObject * obj0 = 0 ;
47396 PyObject * obj1 = 0 ;
47397 char * kwnames[] = {
47398 (char *) "self",(char *) "userData", NULL
47399 };
47400
47401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47403 if (!SWIG_IsOK(res1)) {
47404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47405 }
47406 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47407 arg2 = obj1;
47408 {
47409 PyThreadState* __tstate = wxPyBeginAllowThreads();
47410 wxSizerItem_SetUserData(arg1,arg2);
47411 wxPyEndAllowThreads(__tstate);
47412 if (PyErr_Occurred()) SWIG_fail;
47413 }
47414 resultobj = SWIG_Py_Void();
47415 return resultobj;
47416 fail:
47417 return NULL;
47418 }
47419
47420
47421 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47422 PyObject *obj;
47423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47424 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47425 return SWIG_Py_Void();
47426 }
47427
47428 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47429 return SWIG_Python_InitShadowInstance(args);
47430 }
47431
47432 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47433 PyObject *resultobj = 0;
47434 wxSizer *arg1 = (wxSizer *) 0 ;
47435 void *argp1 = 0 ;
47436 int res1 = 0 ;
47437 PyObject *swig_obj[1] ;
47438
47439 if (!args) SWIG_fail;
47440 swig_obj[0] = args;
47441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47442 if (!SWIG_IsOK(res1)) {
47443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47444 }
47445 arg1 = reinterpret_cast< wxSizer * >(argp1);
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 delete arg1;
47449
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_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47461 PyObject *resultobj = 0;
47462 wxSizer *arg1 = (wxSizer *) 0 ;
47463 PyObject *arg2 = (PyObject *) 0 ;
47464 void *argp1 = 0 ;
47465 int res1 = 0 ;
47466 PyObject * obj0 = 0 ;
47467 PyObject * obj1 = 0 ;
47468 char * kwnames[] = {
47469 (char *) "self",(char *) "_self", NULL
47470 };
47471
47472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47474 if (!SWIG_IsOK(res1)) {
47475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47476 }
47477 arg1 = reinterpret_cast< wxSizer * >(argp1);
47478 arg2 = obj1;
47479 {
47480 PyThreadState* __tstate = wxPyBeginAllowThreads();
47481 wxSizer__setOORInfo(arg1,arg2);
47482 wxPyEndAllowThreads(__tstate);
47483 if (PyErr_Occurred()) SWIG_fail;
47484 }
47485 resultobj = SWIG_Py_Void();
47486 return resultobj;
47487 fail:
47488 return NULL;
47489 }
47490
47491
47492 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47493 PyObject *resultobj = 0;
47494 wxSizer *arg1 = (wxSizer *) 0 ;
47495 PyObject *arg2 = (PyObject *) 0 ;
47496 int arg3 = (int) 0 ;
47497 int arg4 = (int) 0 ;
47498 int arg5 = (int) 0 ;
47499 PyObject *arg6 = (PyObject *) NULL ;
47500 wxSizerItem *result = 0 ;
47501 void *argp1 = 0 ;
47502 int res1 = 0 ;
47503 int val3 ;
47504 int ecode3 = 0 ;
47505 int val4 ;
47506 int ecode4 = 0 ;
47507 int val5 ;
47508 int ecode5 = 0 ;
47509 PyObject * obj0 = 0 ;
47510 PyObject * obj1 = 0 ;
47511 PyObject * obj2 = 0 ;
47512 PyObject * obj3 = 0 ;
47513 PyObject * obj4 = 0 ;
47514 PyObject * obj5 = 0 ;
47515 char * kwnames[] = {
47516 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47517 };
47518
47519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47521 if (!SWIG_IsOK(res1)) {
47522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47523 }
47524 arg1 = reinterpret_cast< wxSizer * >(argp1);
47525 arg2 = obj1;
47526 if (obj2) {
47527 ecode3 = SWIG_AsVal_int(obj2, &val3);
47528 if (!SWIG_IsOK(ecode3)) {
47529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47530 }
47531 arg3 = static_cast< int >(val3);
47532 }
47533 if (obj3) {
47534 ecode4 = SWIG_AsVal_int(obj3, &val4);
47535 if (!SWIG_IsOK(ecode4)) {
47536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47537 }
47538 arg4 = static_cast< int >(val4);
47539 }
47540 if (obj4) {
47541 ecode5 = SWIG_AsVal_int(obj4, &val5);
47542 if (!SWIG_IsOK(ecode5)) {
47543 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47544 }
47545 arg5 = static_cast< int >(val5);
47546 }
47547 if (obj5) {
47548 arg6 = obj5;
47549 }
47550 {
47551 PyThreadState* __tstate = wxPyBeginAllowThreads();
47552 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47553 wxPyEndAllowThreads(__tstate);
47554 if (PyErr_Occurred()) SWIG_fail;
47555 }
47556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47557 return resultobj;
47558 fail:
47559 return NULL;
47560 }
47561
47562
47563 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47564 PyObject *resultobj = 0;
47565 wxSizer *arg1 = (wxSizer *) 0 ;
47566 int arg2 ;
47567 PyObject *arg3 = (PyObject *) 0 ;
47568 int arg4 = (int) 0 ;
47569 int arg5 = (int) 0 ;
47570 int arg6 = (int) 0 ;
47571 PyObject *arg7 = (PyObject *) NULL ;
47572 wxSizerItem *result = 0 ;
47573 void *argp1 = 0 ;
47574 int res1 = 0 ;
47575 int val2 ;
47576 int ecode2 = 0 ;
47577 int val4 ;
47578 int ecode4 = 0 ;
47579 int val5 ;
47580 int ecode5 = 0 ;
47581 int val6 ;
47582 int ecode6 = 0 ;
47583 PyObject * obj0 = 0 ;
47584 PyObject * obj1 = 0 ;
47585 PyObject * obj2 = 0 ;
47586 PyObject * obj3 = 0 ;
47587 PyObject * obj4 = 0 ;
47588 PyObject * obj5 = 0 ;
47589 PyObject * obj6 = 0 ;
47590 char * kwnames[] = {
47591 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47592 };
47593
47594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47596 if (!SWIG_IsOK(res1)) {
47597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47598 }
47599 arg1 = reinterpret_cast< wxSizer * >(argp1);
47600 ecode2 = SWIG_AsVal_int(obj1, &val2);
47601 if (!SWIG_IsOK(ecode2)) {
47602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47603 }
47604 arg2 = static_cast< int >(val2);
47605 arg3 = obj2;
47606 if (obj3) {
47607 ecode4 = SWIG_AsVal_int(obj3, &val4);
47608 if (!SWIG_IsOK(ecode4)) {
47609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47610 }
47611 arg4 = static_cast< int >(val4);
47612 }
47613 if (obj4) {
47614 ecode5 = SWIG_AsVal_int(obj4, &val5);
47615 if (!SWIG_IsOK(ecode5)) {
47616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47617 }
47618 arg5 = static_cast< int >(val5);
47619 }
47620 if (obj5) {
47621 ecode6 = SWIG_AsVal_int(obj5, &val6);
47622 if (!SWIG_IsOK(ecode6)) {
47623 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47624 }
47625 arg6 = static_cast< int >(val6);
47626 }
47627 if (obj6) {
47628 arg7 = obj6;
47629 }
47630 {
47631 PyThreadState* __tstate = wxPyBeginAllowThreads();
47632 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 wxSizer *arg1 = (wxSizer *) 0 ;
47646 PyObject *arg2 = (PyObject *) 0 ;
47647 int arg3 = (int) 0 ;
47648 int arg4 = (int) 0 ;
47649 int arg5 = (int) 0 ;
47650 PyObject *arg6 = (PyObject *) NULL ;
47651 wxSizerItem *result = 0 ;
47652 void *argp1 = 0 ;
47653 int res1 = 0 ;
47654 int val3 ;
47655 int ecode3 = 0 ;
47656 int val4 ;
47657 int ecode4 = 0 ;
47658 int val5 ;
47659 int ecode5 = 0 ;
47660 PyObject * obj0 = 0 ;
47661 PyObject * obj1 = 0 ;
47662 PyObject * obj2 = 0 ;
47663 PyObject * obj3 = 0 ;
47664 PyObject * obj4 = 0 ;
47665 PyObject * obj5 = 0 ;
47666 char * kwnames[] = {
47667 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47668 };
47669
47670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47672 if (!SWIG_IsOK(res1)) {
47673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47674 }
47675 arg1 = reinterpret_cast< wxSizer * >(argp1);
47676 arg2 = obj1;
47677 if (obj2) {
47678 ecode3 = SWIG_AsVal_int(obj2, &val3);
47679 if (!SWIG_IsOK(ecode3)) {
47680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47681 }
47682 arg3 = static_cast< int >(val3);
47683 }
47684 if (obj3) {
47685 ecode4 = SWIG_AsVal_int(obj3, &val4);
47686 if (!SWIG_IsOK(ecode4)) {
47687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47688 }
47689 arg4 = static_cast< int >(val4);
47690 }
47691 if (obj4) {
47692 ecode5 = SWIG_AsVal_int(obj4, &val5);
47693 if (!SWIG_IsOK(ecode5)) {
47694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47695 }
47696 arg5 = static_cast< int >(val5);
47697 }
47698 if (obj5) {
47699 arg6 = obj5;
47700 }
47701 {
47702 PyThreadState* __tstate = wxPyBeginAllowThreads();
47703 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47704 wxPyEndAllowThreads(__tstate);
47705 if (PyErr_Occurred()) SWIG_fail;
47706 }
47707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47708 return resultobj;
47709 fail:
47710 return NULL;
47711 }
47712
47713
47714 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47715 PyObject *resultobj = 0;
47716 wxSizer *arg1 = (wxSizer *) 0 ;
47717 PyObject *arg2 = (PyObject *) 0 ;
47718 bool result;
47719 void *argp1 = 0 ;
47720 int res1 = 0 ;
47721 PyObject * obj0 = 0 ;
47722 PyObject * obj1 = 0 ;
47723 char * kwnames[] = {
47724 (char *) "self",(char *) "item", NULL
47725 };
47726
47727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47729 if (!SWIG_IsOK(res1)) {
47730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47731 }
47732 arg1 = reinterpret_cast< wxSizer * >(argp1);
47733 arg2 = obj1;
47734 {
47735 PyThreadState* __tstate = wxPyBeginAllowThreads();
47736 result = (bool)wxSizer_Remove(arg1,arg2);
47737 wxPyEndAllowThreads(__tstate);
47738 if (PyErr_Occurred()) SWIG_fail;
47739 }
47740 {
47741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47742 }
47743 return resultobj;
47744 fail:
47745 return NULL;
47746 }
47747
47748
47749 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47750 PyObject *resultobj = 0;
47751 wxSizer *arg1 = (wxSizer *) 0 ;
47752 PyObject *arg2 = (PyObject *) 0 ;
47753 bool result;
47754 void *argp1 = 0 ;
47755 int res1 = 0 ;
47756 PyObject * obj0 = 0 ;
47757 PyObject * obj1 = 0 ;
47758 char * kwnames[] = {
47759 (char *) "self",(char *) "item", NULL
47760 };
47761
47762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47764 if (!SWIG_IsOK(res1)) {
47765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47766 }
47767 arg1 = reinterpret_cast< wxSizer * >(argp1);
47768 arg2 = obj1;
47769 {
47770 PyThreadState* __tstate = wxPyBeginAllowThreads();
47771 result = (bool)wxSizer_Detach(arg1,arg2);
47772 wxPyEndAllowThreads(__tstate);
47773 if (PyErr_Occurred()) SWIG_fail;
47774 }
47775 {
47776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47777 }
47778 return resultobj;
47779 fail:
47780 return NULL;
47781 }
47782
47783
47784 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47785 PyObject *resultobj = 0;
47786 wxSizer *arg1 = (wxSizer *) 0 ;
47787 PyObject *arg2 = (PyObject *) 0 ;
47788 wxSizerItem *result = 0 ;
47789 void *argp1 = 0 ;
47790 int res1 = 0 ;
47791 PyObject * obj0 = 0 ;
47792 PyObject * obj1 = 0 ;
47793 char * kwnames[] = {
47794 (char *) "self",(char *) "item", NULL
47795 };
47796
47797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47799 if (!SWIG_IsOK(res1)) {
47800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47801 }
47802 arg1 = reinterpret_cast< wxSizer * >(argp1);
47803 arg2 = obj1;
47804 {
47805 PyThreadState* __tstate = wxPyBeginAllowThreads();
47806 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47807 wxPyEndAllowThreads(__tstate);
47808 if (PyErr_Occurred()) SWIG_fail;
47809 }
47810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47811 return resultobj;
47812 fail:
47813 return NULL;
47814 }
47815
47816
47817 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47818 PyObject *resultobj = 0;
47819 wxSizer *arg1 = (wxSizer *) 0 ;
47820 PyObject *arg2 = (PyObject *) 0 ;
47821 wxSize *arg3 = 0 ;
47822 void *argp1 = 0 ;
47823 int res1 = 0 ;
47824 wxSize temp3 ;
47825 PyObject * obj0 = 0 ;
47826 PyObject * obj1 = 0 ;
47827 PyObject * obj2 = 0 ;
47828 char * kwnames[] = {
47829 (char *) "self",(char *) "item",(char *) "size", NULL
47830 };
47831
47832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47834 if (!SWIG_IsOK(res1)) {
47835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47836 }
47837 arg1 = reinterpret_cast< wxSizer * >(argp1);
47838 arg2 = obj1;
47839 {
47840 arg3 = &temp3;
47841 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47842 }
47843 {
47844 PyThreadState* __tstate = wxPyBeginAllowThreads();
47845 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47846 wxPyEndAllowThreads(__tstate);
47847 if (PyErr_Occurred()) SWIG_fail;
47848 }
47849 resultobj = SWIG_Py_Void();
47850 return resultobj;
47851 fail:
47852 return NULL;
47853 }
47854
47855
47856 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47857 PyObject *resultobj = 0;
47858 wxSizer *arg1 = (wxSizer *) 0 ;
47859 wxWindow *arg2 = (wxWindow *) 0 ;
47860 wxWindow *arg3 = (wxWindow *) 0 ;
47861 bool arg4 = (bool) false ;
47862 bool result;
47863 void *argp1 = 0 ;
47864 int res1 = 0 ;
47865 void *argp2 = 0 ;
47866 int res2 = 0 ;
47867 void *argp3 = 0 ;
47868 int res3 = 0 ;
47869 bool val4 ;
47870 int ecode4 = 0 ;
47871 PyObject * obj0 = 0 ;
47872 PyObject * obj1 = 0 ;
47873 PyObject * obj2 = 0 ;
47874 PyObject * obj3 = 0 ;
47875 char * kwnames[] = {
47876 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47877 };
47878
47879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47881 if (!SWIG_IsOK(res1)) {
47882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47883 }
47884 arg1 = reinterpret_cast< wxSizer * >(argp1);
47885 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47886 if (!SWIG_IsOK(res2)) {
47887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47888 }
47889 arg2 = reinterpret_cast< wxWindow * >(argp2);
47890 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47891 if (!SWIG_IsOK(res3)) {
47892 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47893 }
47894 arg3 = reinterpret_cast< wxWindow * >(argp3);
47895 if (obj3) {
47896 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47897 if (!SWIG_IsOK(ecode4)) {
47898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47899 }
47900 arg4 = static_cast< bool >(val4);
47901 }
47902 {
47903 PyThreadState* __tstate = wxPyBeginAllowThreads();
47904 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47905 wxPyEndAllowThreads(__tstate);
47906 if (PyErr_Occurred()) SWIG_fail;
47907 }
47908 {
47909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47910 }
47911 return resultobj;
47912 fail:
47913 return NULL;
47914 }
47915
47916
47917 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47918 PyObject *resultobj = 0;
47919 wxSizer *arg1 = (wxSizer *) 0 ;
47920 wxSizer *arg2 = (wxSizer *) 0 ;
47921 wxSizer *arg3 = (wxSizer *) 0 ;
47922 bool arg4 = (bool) false ;
47923 bool result;
47924 void *argp1 = 0 ;
47925 int res1 = 0 ;
47926 void *argp2 = 0 ;
47927 int res2 = 0 ;
47928 void *argp3 = 0 ;
47929 int res3 = 0 ;
47930 bool val4 ;
47931 int ecode4 = 0 ;
47932 PyObject * obj0 = 0 ;
47933 PyObject * obj1 = 0 ;
47934 PyObject * obj2 = 0 ;
47935 PyObject * obj3 = 0 ;
47936 char * kwnames[] = {
47937 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47938 };
47939
47940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47942 if (!SWIG_IsOK(res1)) {
47943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47944 }
47945 arg1 = reinterpret_cast< wxSizer * >(argp1);
47946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47947 if (!SWIG_IsOK(res2)) {
47948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47949 }
47950 arg2 = reinterpret_cast< wxSizer * >(argp2);
47951 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47952 if (!SWIG_IsOK(res3)) {
47953 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47954 }
47955 arg3 = reinterpret_cast< wxSizer * >(argp3);
47956 if (obj3) {
47957 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47958 if (!SWIG_IsOK(ecode4)) {
47959 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47960 }
47961 arg4 = static_cast< bool >(val4);
47962 }
47963 {
47964 PyThreadState* __tstate = wxPyBeginAllowThreads();
47965 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47966 wxPyEndAllowThreads(__tstate);
47967 if (PyErr_Occurred()) SWIG_fail;
47968 }
47969 {
47970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47971 }
47972 return resultobj;
47973 fail:
47974 return NULL;
47975 }
47976
47977
47978 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47979 PyObject *resultobj = 0;
47980 wxSizer *arg1 = (wxSizer *) 0 ;
47981 size_t arg2 ;
47982 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47983 bool result;
47984 void *argp1 = 0 ;
47985 int res1 = 0 ;
47986 size_t val2 ;
47987 int ecode2 = 0 ;
47988 void *argp3 = 0 ;
47989 int res3 = 0 ;
47990 PyObject * obj0 = 0 ;
47991 PyObject * obj1 = 0 ;
47992 PyObject * obj2 = 0 ;
47993 char * kwnames[] = {
47994 (char *) "self",(char *) "index",(char *) "newitem", NULL
47995 };
47996
47997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47999 if (!SWIG_IsOK(res1)) {
48000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48001 }
48002 arg1 = reinterpret_cast< wxSizer * >(argp1);
48003 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48004 if (!SWIG_IsOK(ecode2)) {
48005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48006 }
48007 arg2 = static_cast< size_t >(val2);
48008 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48009 if (!SWIG_IsOK(res3)) {
48010 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48011 }
48012 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48013 {
48014 PyThreadState* __tstate = wxPyBeginAllowThreads();
48015 result = (bool)(arg1)->Replace(arg2,arg3);
48016 wxPyEndAllowThreads(__tstate);
48017 if (PyErr_Occurred()) SWIG_fail;
48018 }
48019 {
48020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48021 }
48022 return resultobj;
48023 fail:
48024 return NULL;
48025 }
48026
48027
48028 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48029 PyObject *resultobj = 0;
48030 wxSizer *arg1 = (wxSizer *) 0 ;
48031 wxWindow *arg2 = (wxWindow *) 0 ;
48032 void *argp1 = 0 ;
48033 int res1 = 0 ;
48034 void *argp2 = 0 ;
48035 int res2 = 0 ;
48036 PyObject * obj0 = 0 ;
48037 PyObject * obj1 = 0 ;
48038 char * kwnames[] = {
48039 (char *) "self",(char *) "window", NULL
48040 };
48041
48042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48044 if (!SWIG_IsOK(res1)) {
48045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48046 }
48047 arg1 = reinterpret_cast< wxSizer * >(argp1);
48048 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48049 if (!SWIG_IsOK(res2)) {
48050 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48051 }
48052 arg2 = reinterpret_cast< wxWindow * >(argp2);
48053 {
48054 PyThreadState* __tstate = wxPyBeginAllowThreads();
48055 (arg1)->SetContainingWindow(arg2);
48056 wxPyEndAllowThreads(__tstate);
48057 if (PyErr_Occurred()) SWIG_fail;
48058 }
48059 resultobj = SWIG_Py_Void();
48060 return resultobj;
48061 fail:
48062 return NULL;
48063 }
48064
48065
48066 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48067 PyObject *resultobj = 0;
48068 wxSizer *arg1 = (wxSizer *) 0 ;
48069 wxWindow *result = 0 ;
48070 void *argp1 = 0 ;
48071 int res1 = 0 ;
48072 PyObject *swig_obj[1] ;
48073
48074 if (!args) SWIG_fail;
48075 swig_obj[0] = args;
48076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48077 if (!SWIG_IsOK(res1)) {
48078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48079 }
48080 arg1 = reinterpret_cast< wxSizer * >(argp1);
48081 {
48082 PyThreadState* __tstate = wxPyBeginAllowThreads();
48083 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48084 wxPyEndAllowThreads(__tstate);
48085 if (PyErr_Occurred()) SWIG_fail;
48086 }
48087 {
48088 resultobj = wxPyMake_wxObject(result, 0);
48089 }
48090 return resultobj;
48091 fail:
48092 return NULL;
48093 }
48094
48095
48096 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48097 PyObject *resultobj = 0;
48098 wxSizer *arg1 = (wxSizer *) 0 ;
48099 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48100 wxSizerItem *result = 0 ;
48101 void *argp1 = 0 ;
48102 int res1 = 0 ;
48103 int res2 = 0 ;
48104 PyObject * obj0 = 0 ;
48105 PyObject * obj1 = 0 ;
48106 char * kwnames[] = {
48107 (char *) "self",(char *) "item", NULL
48108 };
48109
48110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48112 if (!SWIG_IsOK(res1)) {
48113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48114 }
48115 arg1 = reinterpret_cast< wxSizer * >(argp1);
48116 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48117 if (!SWIG_IsOK(res2)) {
48118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48119 }
48120 {
48121 PyThreadState* __tstate = wxPyBeginAllowThreads();
48122 result = (wxSizerItem *)(arg1)->Add(arg2);
48123 wxPyEndAllowThreads(__tstate);
48124 if (PyErr_Occurred()) SWIG_fail;
48125 }
48126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48127 return resultobj;
48128 fail:
48129 return NULL;
48130 }
48131
48132
48133 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48134 PyObject *resultobj = 0;
48135 wxSizer *arg1 = (wxSizer *) 0 ;
48136 size_t arg2 ;
48137 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48138 wxSizerItem *result = 0 ;
48139 void *argp1 = 0 ;
48140 int res1 = 0 ;
48141 size_t val2 ;
48142 int ecode2 = 0 ;
48143 int res3 = 0 ;
48144 PyObject * obj0 = 0 ;
48145 PyObject * obj1 = 0 ;
48146 PyObject * obj2 = 0 ;
48147 char * kwnames[] = {
48148 (char *) "self",(char *) "index",(char *) "item", NULL
48149 };
48150
48151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48153 if (!SWIG_IsOK(res1)) {
48154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48155 }
48156 arg1 = reinterpret_cast< wxSizer * >(argp1);
48157 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48158 if (!SWIG_IsOK(ecode2)) {
48159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48160 }
48161 arg2 = static_cast< size_t >(val2);
48162 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48163 if (!SWIG_IsOK(res3)) {
48164 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48165 }
48166 {
48167 PyThreadState* __tstate = wxPyBeginAllowThreads();
48168 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48169 wxPyEndAllowThreads(__tstate);
48170 if (PyErr_Occurred()) SWIG_fail;
48171 }
48172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48173 return resultobj;
48174 fail:
48175 return NULL;
48176 }
48177
48178
48179 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48180 PyObject *resultobj = 0;
48181 wxSizer *arg1 = (wxSizer *) 0 ;
48182 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48183 wxSizerItem *result = 0 ;
48184 void *argp1 = 0 ;
48185 int res1 = 0 ;
48186 int res2 = 0 ;
48187 PyObject * obj0 = 0 ;
48188 PyObject * obj1 = 0 ;
48189 char * kwnames[] = {
48190 (char *) "self",(char *) "item", NULL
48191 };
48192
48193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48195 if (!SWIG_IsOK(res1)) {
48196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48197 }
48198 arg1 = reinterpret_cast< wxSizer * >(argp1);
48199 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48200 if (!SWIG_IsOK(res2)) {
48201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48202 }
48203 {
48204 PyThreadState* __tstate = wxPyBeginAllowThreads();
48205 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48206 wxPyEndAllowThreads(__tstate);
48207 if (PyErr_Occurred()) SWIG_fail;
48208 }
48209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48210 return resultobj;
48211 fail:
48212 return NULL;
48213 }
48214
48215
48216 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48217 PyObject *resultobj = 0;
48218 wxSizer *arg1 = (wxSizer *) 0 ;
48219 int arg2 ;
48220 int arg3 ;
48221 int arg4 ;
48222 int arg5 ;
48223 void *argp1 = 0 ;
48224 int res1 = 0 ;
48225 int val2 ;
48226 int ecode2 = 0 ;
48227 int val3 ;
48228 int ecode3 = 0 ;
48229 int val4 ;
48230 int ecode4 = 0 ;
48231 int val5 ;
48232 int ecode5 = 0 ;
48233 PyObject * obj0 = 0 ;
48234 PyObject * obj1 = 0 ;
48235 PyObject * obj2 = 0 ;
48236 PyObject * obj3 = 0 ;
48237 PyObject * obj4 = 0 ;
48238 char * kwnames[] = {
48239 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48240 };
48241
48242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48244 if (!SWIG_IsOK(res1)) {
48245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48246 }
48247 arg1 = reinterpret_cast< wxSizer * >(argp1);
48248 ecode2 = SWIG_AsVal_int(obj1, &val2);
48249 if (!SWIG_IsOK(ecode2)) {
48250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48251 }
48252 arg2 = static_cast< int >(val2);
48253 ecode3 = SWIG_AsVal_int(obj2, &val3);
48254 if (!SWIG_IsOK(ecode3)) {
48255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48256 }
48257 arg3 = static_cast< int >(val3);
48258 ecode4 = SWIG_AsVal_int(obj3, &val4);
48259 if (!SWIG_IsOK(ecode4)) {
48260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48261 }
48262 arg4 = static_cast< int >(val4);
48263 ecode5 = SWIG_AsVal_int(obj4, &val5);
48264 if (!SWIG_IsOK(ecode5)) {
48265 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48266 }
48267 arg5 = static_cast< int >(val5);
48268 {
48269 PyThreadState* __tstate = wxPyBeginAllowThreads();
48270 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48271 wxPyEndAllowThreads(__tstate);
48272 if (PyErr_Occurred()) SWIG_fail;
48273 }
48274 resultobj = SWIG_Py_Void();
48275 return resultobj;
48276 fail:
48277 return NULL;
48278 }
48279
48280
48281 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48282 PyObject *resultobj = 0;
48283 wxSizer *arg1 = (wxSizer *) 0 ;
48284 wxSize *arg2 = 0 ;
48285 void *argp1 = 0 ;
48286 int res1 = 0 ;
48287 wxSize temp2 ;
48288 PyObject * obj0 = 0 ;
48289 PyObject * obj1 = 0 ;
48290 char * kwnames[] = {
48291 (char *) "self",(char *) "size", NULL
48292 };
48293
48294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48296 if (!SWIG_IsOK(res1)) {
48297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48298 }
48299 arg1 = reinterpret_cast< wxSizer * >(argp1);
48300 {
48301 arg2 = &temp2;
48302 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48303 }
48304 {
48305 PyThreadState* __tstate = wxPyBeginAllowThreads();
48306 (arg1)->SetMinSize((wxSize const &)*arg2);
48307 wxPyEndAllowThreads(__tstate);
48308 if (PyErr_Occurred()) SWIG_fail;
48309 }
48310 resultobj = SWIG_Py_Void();
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48318 PyObject *resultobj = 0;
48319 wxSizer *arg1 = (wxSizer *) 0 ;
48320 wxSize result;
48321 void *argp1 = 0 ;
48322 int res1 = 0 ;
48323 PyObject *swig_obj[1] ;
48324
48325 if (!args) SWIG_fail;
48326 swig_obj[0] = args;
48327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48328 if (!SWIG_IsOK(res1)) {
48329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48330 }
48331 arg1 = reinterpret_cast< wxSizer * >(argp1);
48332 {
48333 PyThreadState* __tstate = wxPyBeginAllowThreads();
48334 result = (arg1)->GetSize();
48335 wxPyEndAllowThreads(__tstate);
48336 if (PyErr_Occurred()) SWIG_fail;
48337 }
48338 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48339 return resultobj;
48340 fail:
48341 return NULL;
48342 }
48343
48344
48345 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48346 PyObject *resultobj = 0;
48347 wxSizer *arg1 = (wxSizer *) 0 ;
48348 wxPoint result;
48349 void *argp1 = 0 ;
48350 int res1 = 0 ;
48351 PyObject *swig_obj[1] ;
48352
48353 if (!args) SWIG_fail;
48354 swig_obj[0] = args;
48355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48356 if (!SWIG_IsOK(res1)) {
48357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48358 }
48359 arg1 = reinterpret_cast< wxSizer * >(argp1);
48360 {
48361 PyThreadState* __tstate = wxPyBeginAllowThreads();
48362 result = (arg1)->GetPosition();
48363 wxPyEndAllowThreads(__tstate);
48364 if (PyErr_Occurred()) SWIG_fail;
48365 }
48366 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48367 return resultobj;
48368 fail:
48369 return NULL;
48370 }
48371
48372
48373 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48374 PyObject *resultobj = 0;
48375 wxSizer *arg1 = (wxSizer *) 0 ;
48376 wxSize result;
48377 void *argp1 = 0 ;
48378 int res1 = 0 ;
48379 PyObject *swig_obj[1] ;
48380
48381 if (!args) SWIG_fail;
48382 swig_obj[0] = args;
48383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48384 if (!SWIG_IsOK(res1)) {
48385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48386 }
48387 arg1 = reinterpret_cast< wxSizer * >(argp1);
48388 {
48389 PyThreadState* __tstate = wxPyBeginAllowThreads();
48390 result = (arg1)->GetMinSize();
48391 wxPyEndAllowThreads(__tstate);
48392 if (PyErr_Occurred()) SWIG_fail;
48393 }
48394 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48395 return resultobj;
48396 fail:
48397 return NULL;
48398 }
48399
48400
48401 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48402 PyObject *resultobj = 0;
48403 wxSizer *arg1 = (wxSizer *) 0 ;
48404 void *argp1 = 0 ;
48405 int res1 = 0 ;
48406 PyObject *swig_obj[1] ;
48407
48408 if (!args) SWIG_fail;
48409 swig_obj[0] = args;
48410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48411 if (!SWIG_IsOK(res1)) {
48412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48413 }
48414 arg1 = reinterpret_cast< wxSizer * >(argp1);
48415 {
48416 PyThreadState* __tstate = wxPyBeginAllowThreads();
48417 (arg1)->RecalcSizes();
48418 wxPyEndAllowThreads(__tstate);
48419 if (PyErr_Occurred()) SWIG_fail;
48420 }
48421 resultobj = SWIG_Py_Void();
48422 return resultobj;
48423 fail:
48424 return NULL;
48425 }
48426
48427
48428 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48429 PyObject *resultobj = 0;
48430 wxSizer *arg1 = (wxSizer *) 0 ;
48431 wxSize result;
48432 void *argp1 = 0 ;
48433 int res1 = 0 ;
48434 PyObject *swig_obj[1] ;
48435
48436 if (!args) SWIG_fail;
48437 swig_obj[0] = args;
48438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48439 if (!SWIG_IsOK(res1)) {
48440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48441 }
48442 arg1 = reinterpret_cast< wxSizer * >(argp1);
48443 {
48444 PyThreadState* __tstate = wxPyBeginAllowThreads();
48445 result = (arg1)->CalcMin();
48446 wxPyEndAllowThreads(__tstate);
48447 if (PyErr_Occurred()) SWIG_fail;
48448 }
48449 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48450 return resultobj;
48451 fail:
48452 return NULL;
48453 }
48454
48455
48456 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48457 PyObject *resultobj = 0;
48458 wxSizer *arg1 = (wxSizer *) 0 ;
48459 void *argp1 = 0 ;
48460 int res1 = 0 ;
48461 PyObject *swig_obj[1] ;
48462
48463 if (!args) SWIG_fail;
48464 swig_obj[0] = args;
48465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48466 if (!SWIG_IsOK(res1)) {
48467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48468 }
48469 arg1 = reinterpret_cast< wxSizer * >(argp1);
48470 {
48471 PyThreadState* __tstate = wxPyBeginAllowThreads();
48472 (arg1)->Layout();
48473 wxPyEndAllowThreads(__tstate);
48474 if (PyErr_Occurred()) SWIG_fail;
48475 }
48476 resultobj = SWIG_Py_Void();
48477 return resultobj;
48478 fail:
48479 return NULL;
48480 }
48481
48482
48483 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48484 PyObject *resultobj = 0;
48485 wxSizer *arg1 = (wxSizer *) 0 ;
48486 wxWindow *arg2 = (wxWindow *) 0 ;
48487 wxSize result;
48488 void *argp1 = 0 ;
48489 int res1 = 0 ;
48490 void *argp2 = 0 ;
48491 int res2 = 0 ;
48492 PyObject * obj0 = 0 ;
48493 PyObject * obj1 = 0 ;
48494 char * kwnames[] = {
48495 (char *) "self",(char *) "window", NULL
48496 };
48497
48498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48500 if (!SWIG_IsOK(res1)) {
48501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48502 }
48503 arg1 = reinterpret_cast< wxSizer * >(argp1);
48504 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48505 if (!SWIG_IsOK(res2)) {
48506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48507 }
48508 arg2 = reinterpret_cast< wxWindow * >(argp2);
48509 {
48510 PyThreadState* __tstate = wxPyBeginAllowThreads();
48511 result = (arg1)->Fit(arg2);
48512 wxPyEndAllowThreads(__tstate);
48513 if (PyErr_Occurred()) SWIG_fail;
48514 }
48515 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48516 return resultobj;
48517 fail:
48518 return NULL;
48519 }
48520
48521
48522 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48523 PyObject *resultobj = 0;
48524 wxSizer *arg1 = (wxSizer *) 0 ;
48525 wxWindow *arg2 = (wxWindow *) 0 ;
48526 void *argp1 = 0 ;
48527 int res1 = 0 ;
48528 void *argp2 = 0 ;
48529 int res2 = 0 ;
48530 PyObject * obj0 = 0 ;
48531 PyObject * obj1 = 0 ;
48532 char * kwnames[] = {
48533 (char *) "self",(char *) "window", NULL
48534 };
48535
48536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48538 if (!SWIG_IsOK(res1)) {
48539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48540 }
48541 arg1 = reinterpret_cast< wxSizer * >(argp1);
48542 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48543 if (!SWIG_IsOK(res2)) {
48544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48545 }
48546 arg2 = reinterpret_cast< wxWindow * >(argp2);
48547 {
48548 PyThreadState* __tstate = wxPyBeginAllowThreads();
48549 (arg1)->FitInside(arg2);
48550 wxPyEndAllowThreads(__tstate);
48551 if (PyErr_Occurred()) SWIG_fail;
48552 }
48553 resultobj = SWIG_Py_Void();
48554 return resultobj;
48555 fail:
48556 return NULL;
48557 }
48558
48559
48560 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48561 PyObject *resultobj = 0;
48562 wxSizer *arg1 = (wxSizer *) 0 ;
48563 wxWindow *arg2 = (wxWindow *) 0 ;
48564 void *argp1 = 0 ;
48565 int res1 = 0 ;
48566 void *argp2 = 0 ;
48567 int res2 = 0 ;
48568 PyObject * obj0 = 0 ;
48569 PyObject * obj1 = 0 ;
48570 char * kwnames[] = {
48571 (char *) "self",(char *) "window", NULL
48572 };
48573
48574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48576 if (!SWIG_IsOK(res1)) {
48577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48578 }
48579 arg1 = reinterpret_cast< wxSizer * >(argp1);
48580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48581 if (!SWIG_IsOK(res2)) {
48582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48583 }
48584 arg2 = reinterpret_cast< wxWindow * >(argp2);
48585 {
48586 PyThreadState* __tstate = wxPyBeginAllowThreads();
48587 (arg1)->SetSizeHints(arg2);
48588 wxPyEndAllowThreads(__tstate);
48589 if (PyErr_Occurred()) SWIG_fail;
48590 }
48591 resultobj = SWIG_Py_Void();
48592 return resultobj;
48593 fail:
48594 return NULL;
48595 }
48596
48597
48598 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48599 PyObject *resultobj = 0;
48600 wxSizer *arg1 = (wxSizer *) 0 ;
48601 wxWindow *arg2 = (wxWindow *) 0 ;
48602 void *argp1 = 0 ;
48603 int res1 = 0 ;
48604 void *argp2 = 0 ;
48605 int res2 = 0 ;
48606 PyObject * obj0 = 0 ;
48607 PyObject * obj1 = 0 ;
48608 char * kwnames[] = {
48609 (char *) "self",(char *) "window", NULL
48610 };
48611
48612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48614 if (!SWIG_IsOK(res1)) {
48615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48616 }
48617 arg1 = reinterpret_cast< wxSizer * >(argp1);
48618 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48619 if (!SWIG_IsOK(res2)) {
48620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48621 }
48622 arg2 = reinterpret_cast< wxWindow * >(argp2);
48623 {
48624 PyThreadState* __tstate = wxPyBeginAllowThreads();
48625 (arg1)->SetVirtualSizeHints(arg2);
48626 wxPyEndAllowThreads(__tstate);
48627 if (PyErr_Occurred()) SWIG_fail;
48628 }
48629 resultobj = SWIG_Py_Void();
48630 return resultobj;
48631 fail:
48632 return NULL;
48633 }
48634
48635
48636 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48637 PyObject *resultobj = 0;
48638 wxSizer *arg1 = (wxSizer *) 0 ;
48639 bool arg2 = (bool) false ;
48640 void *argp1 = 0 ;
48641 int res1 = 0 ;
48642 bool val2 ;
48643 int ecode2 = 0 ;
48644 PyObject * obj0 = 0 ;
48645 PyObject * obj1 = 0 ;
48646 char * kwnames[] = {
48647 (char *) "self",(char *) "deleteWindows", NULL
48648 };
48649
48650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48652 if (!SWIG_IsOK(res1)) {
48653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48654 }
48655 arg1 = reinterpret_cast< wxSizer * >(argp1);
48656 if (obj1) {
48657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48658 if (!SWIG_IsOK(ecode2)) {
48659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48660 }
48661 arg2 = static_cast< bool >(val2);
48662 }
48663 {
48664 PyThreadState* __tstate = wxPyBeginAllowThreads();
48665 (arg1)->Clear(arg2);
48666 wxPyEndAllowThreads(__tstate);
48667 if (PyErr_Occurred()) SWIG_fail;
48668 }
48669 resultobj = SWIG_Py_Void();
48670 return resultobj;
48671 fail:
48672 return NULL;
48673 }
48674
48675
48676 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48677 PyObject *resultobj = 0;
48678 wxSizer *arg1 = (wxSizer *) 0 ;
48679 void *argp1 = 0 ;
48680 int res1 = 0 ;
48681 PyObject *swig_obj[1] ;
48682
48683 if (!args) SWIG_fail;
48684 swig_obj[0] = args;
48685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48686 if (!SWIG_IsOK(res1)) {
48687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48688 }
48689 arg1 = reinterpret_cast< wxSizer * >(argp1);
48690 {
48691 PyThreadState* __tstate = wxPyBeginAllowThreads();
48692 (arg1)->DeleteWindows();
48693 wxPyEndAllowThreads(__tstate);
48694 if (PyErr_Occurred()) SWIG_fail;
48695 }
48696 resultobj = SWIG_Py_Void();
48697 return resultobj;
48698 fail:
48699 return NULL;
48700 }
48701
48702
48703 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48704 PyObject *resultobj = 0;
48705 wxSizer *arg1 = (wxSizer *) 0 ;
48706 PyObject *result = 0 ;
48707 void *argp1 = 0 ;
48708 int res1 = 0 ;
48709 PyObject *swig_obj[1] ;
48710
48711 if (!args) SWIG_fail;
48712 swig_obj[0] = args;
48713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48714 if (!SWIG_IsOK(res1)) {
48715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48716 }
48717 arg1 = reinterpret_cast< wxSizer * >(argp1);
48718 {
48719 PyThreadState* __tstate = wxPyBeginAllowThreads();
48720 result = (PyObject *)wxSizer_GetChildren(arg1);
48721 wxPyEndAllowThreads(__tstate);
48722 if (PyErr_Occurred()) SWIG_fail;
48723 }
48724 resultobj = result;
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48732 PyObject *resultobj = 0;
48733 wxSizer *arg1 = (wxSizer *) 0 ;
48734 PyObject *arg2 = (PyObject *) 0 ;
48735 bool arg3 = (bool) true ;
48736 bool arg4 = (bool) false ;
48737 bool result;
48738 void *argp1 = 0 ;
48739 int res1 = 0 ;
48740 bool val3 ;
48741 int ecode3 = 0 ;
48742 bool val4 ;
48743 int ecode4 = 0 ;
48744 PyObject * obj0 = 0 ;
48745 PyObject * obj1 = 0 ;
48746 PyObject * obj2 = 0 ;
48747 PyObject * obj3 = 0 ;
48748 char * kwnames[] = {
48749 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48750 };
48751
48752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48754 if (!SWIG_IsOK(res1)) {
48755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48756 }
48757 arg1 = reinterpret_cast< wxSizer * >(argp1);
48758 arg2 = obj1;
48759 if (obj2) {
48760 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48761 if (!SWIG_IsOK(ecode3)) {
48762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48763 }
48764 arg3 = static_cast< bool >(val3);
48765 }
48766 if (obj3) {
48767 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48768 if (!SWIG_IsOK(ecode4)) {
48769 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48770 }
48771 arg4 = static_cast< bool >(val4);
48772 }
48773 {
48774 PyThreadState* __tstate = wxPyBeginAllowThreads();
48775 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48776 wxPyEndAllowThreads(__tstate);
48777 if (PyErr_Occurred()) SWIG_fail;
48778 }
48779 {
48780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48781 }
48782 return resultobj;
48783 fail:
48784 return NULL;
48785 }
48786
48787
48788 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48789 PyObject *resultobj = 0;
48790 wxSizer *arg1 = (wxSizer *) 0 ;
48791 PyObject *arg2 = (PyObject *) 0 ;
48792 bool result;
48793 void *argp1 = 0 ;
48794 int res1 = 0 ;
48795 PyObject * obj0 = 0 ;
48796 PyObject * obj1 = 0 ;
48797 char * kwnames[] = {
48798 (char *) "self",(char *) "item", NULL
48799 };
48800
48801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48803 if (!SWIG_IsOK(res1)) {
48804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48805 }
48806 arg1 = reinterpret_cast< wxSizer * >(argp1);
48807 arg2 = obj1;
48808 {
48809 PyThreadState* __tstate = wxPyBeginAllowThreads();
48810 result = (bool)wxSizer_IsShown(arg1,arg2);
48811 wxPyEndAllowThreads(__tstate);
48812 if (PyErr_Occurred()) SWIG_fail;
48813 }
48814 {
48815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48816 }
48817 return resultobj;
48818 fail:
48819 return NULL;
48820 }
48821
48822
48823 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48824 PyObject *resultobj = 0;
48825 wxSizer *arg1 = (wxSizer *) 0 ;
48826 bool arg2 ;
48827 void *argp1 = 0 ;
48828 int res1 = 0 ;
48829 bool val2 ;
48830 int ecode2 = 0 ;
48831 PyObject * obj0 = 0 ;
48832 PyObject * obj1 = 0 ;
48833 char * kwnames[] = {
48834 (char *) "self",(char *) "show", NULL
48835 };
48836
48837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48839 if (!SWIG_IsOK(res1)) {
48840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48841 }
48842 arg1 = reinterpret_cast< wxSizer * >(argp1);
48843 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48844 if (!SWIG_IsOK(ecode2)) {
48845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48846 }
48847 arg2 = static_cast< bool >(val2);
48848 {
48849 PyThreadState* __tstate = wxPyBeginAllowThreads();
48850 (arg1)->ShowItems(arg2);
48851 wxPyEndAllowThreads(__tstate);
48852 if (PyErr_Occurred()) SWIG_fail;
48853 }
48854 resultobj = SWIG_Py_Void();
48855 return resultobj;
48856 fail:
48857 return NULL;
48858 }
48859
48860
48861 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48862 PyObject *obj;
48863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48864 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48865 return SWIG_Py_Void();
48866 }
48867
48868 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48869 PyObject *resultobj = 0;
48870 wxPySizer *result = 0 ;
48871
48872 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48873 {
48874 PyThreadState* __tstate = wxPyBeginAllowThreads();
48875 result = (wxPySizer *)new wxPySizer();
48876 wxPyEndAllowThreads(__tstate);
48877 if (PyErr_Occurred()) SWIG_fail;
48878 }
48879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48880 return resultobj;
48881 fail:
48882 return NULL;
48883 }
48884
48885
48886 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48887 PyObject *resultobj = 0;
48888 wxPySizer *arg1 = (wxPySizer *) 0 ;
48889 PyObject *arg2 = (PyObject *) 0 ;
48890 PyObject *arg3 = (PyObject *) 0 ;
48891 void *argp1 = 0 ;
48892 int res1 = 0 ;
48893 PyObject * obj0 = 0 ;
48894 PyObject * obj1 = 0 ;
48895 PyObject * obj2 = 0 ;
48896 char * kwnames[] = {
48897 (char *) "self",(char *) "self",(char *) "_class", NULL
48898 };
48899
48900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48902 if (!SWIG_IsOK(res1)) {
48903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48904 }
48905 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48906 arg2 = obj1;
48907 arg3 = obj2;
48908 {
48909 PyThreadState* __tstate = wxPyBeginAllowThreads();
48910 (arg1)->_setCallbackInfo(arg2,arg3);
48911 wxPyEndAllowThreads(__tstate);
48912 if (PyErr_Occurred()) SWIG_fail;
48913 }
48914 resultobj = SWIG_Py_Void();
48915 return resultobj;
48916 fail:
48917 return NULL;
48918 }
48919
48920
48921 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48922 PyObject *obj;
48923 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48924 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48925 return SWIG_Py_Void();
48926 }
48927
48928 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48929 return SWIG_Python_InitShadowInstance(args);
48930 }
48931
48932 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48933 PyObject *resultobj = 0;
48934 int arg1 = (int) wxHORIZONTAL ;
48935 wxBoxSizer *result = 0 ;
48936 int val1 ;
48937 int ecode1 = 0 ;
48938 PyObject * obj0 = 0 ;
48939 char * kwnames[] = {
48940 (char *) "orient", NULL
48941 };
48942
48943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48944 if (obj0) {
48945 ecode1 = SWIG_AsVal_int(obj0, &val1);
48946 if (!SWIG_IsOK(ecode1)) {
48947 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48948 }
48949 arg1 = static_cast< int >(val1);
48950 }
48951 {
48952 PyThreadState* __tstate = wxPyBeginAllowThreads();
48953 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48954 wxPyEndAllowThreads(__tstate);
48955 if (PyErr_Occurred()) SWIG_fail;
48956 }
48957 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48958 return resultobj;
48959 fail:
48960 return NULL;
48961 }
48962
48963
48964 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48965 PyObject *resultobj = 0;
48966 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48967 int result;
48968 void *argp1 = 0 ;
48969 int res1 = 0 ;
48970 PyObject *swig_obj[1] ;
48971
48972 if (!args) SWIG_fail;
48973 swig_obj[0] = args;
48974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48975 if (!SWIG_IsOK(res1)) {
48976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48977 }
48978 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48979 {
48980 PyThreadState* __tstate = wxPyBeginAllowThreads();
48981 result = (int)(arg1)->GetOrientation();
48982 wxPyEndAllowThreads(__tstate);
48983 if (PyErr_Occurred()) SWIG_fail;
48984 }
48985 resultobj = SWIG_From_int(static_cast< int >(result));
48986 return resultobj;
48987 fail:
48988 return NULL;
48989 }
48990
48991
48992 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48993 PyObject *resultobj = 0;
48994 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48995 int arg2 ;
48996 void *argp1 = 0 ;
48997 int res1 = 0 ;
48998 int val2 ;
48999 int ecode2 = 0 ;
49000 PyObject * obj0 = 0 ;
49001 PyObject * obj1 = 0 ;
49002 char * kwnames[] = {
49003 (char *) "self",(char *) "orient", NULL
49004 };
49005
49006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49008 if (!SWIG_IsOK(res1)) {
49009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49010 }
49011 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49012 ecode2 = SWIG_AsVal_int(obj1, &val2);
49013 if (!SWIG_IsOK(ecode2)) {
49014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49015 }
49016 arg2 = static_cast< int >(val2);
49017 {
49018 PyThreadState* __tstate = wxPyBeginAllowThreads();
49019 (arg1)->SetOrientation(arg2);
49020 wxPyEndAllowThreads(__tstate);
49021 if (PyErr_Occurred()) SWIG_fail;
49022 }
49023 resultobj = SWIG_Py_Void();
49024 return resultobj;
49025 fail:
49026 return NULL;
49027 }
49028
49029
49030 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49031 PyObject *obj;
49032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49033 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49034 return SWIG_Py_Void();
49035 }
49036
49037 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49038 return SWIG_Python_InitShadowInstance(args);
49039 }
49040
49041 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49042 PyObject *resultobj = 0;
49043 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49044 int arg2 = (int) wxHORIZONTAL ;
49045 wxStaticBoxSizer *result = 0 ;
49046 void *argp1 = 0 ;
49047 int res1 = 0 ;
49048 int val2 ;
49049 int ecode2 = 0 ;
49050 PyObject * obj0 = 0 ;
49051 PyObject * obj1 = 0 ;
49052 char * kwnames[] = {
49053 (char *) "box",(char *) "orient", NULL
49054 };
49055
49056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49058 if (!SWIG_IsOK(res1)) {
49059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49060 }
49061 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49062 if (obj1) {
49063 ecode2 = SWIG_AsVal_int(obj1, &val2);
49064 if (!SWIG_IsOK(ecode2)) {
49065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49066 }
49067 arg2 = static_cast< int >(val2);
49068 }
49069 {
49070 PyThreadState* __tstate = wxPyBeginAllowThreads();
49071 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49072 wxPyEndAllowThreads(__tstate);
49073 if (PyErr_Occurred()) SWIG_fail;
49074 }
49075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49076 return resultobj;
49077 fail:
49078 return NULL;
49079 }
49080
49081
49082 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49083 PyObject *resultobj = 0;
49084 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49085 wxStaticBox *result = 0 ;
49086 void *argp1 = 0 ;
49087 int res1 = 0 ;
49088 PyObject *swig_obj[1] ;
49089
49090 if (!args) SWIG_fail;
49091 swig_obj[0] = args;
49092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49093 if (!SWIG_IsOK(res1)) {
49094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49095 }
49096 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49097 {
49098 PyThreadState* __tstate = wxPyBeginAllowThreads();
49099 result = (wxStaticBox *)(arg1)->GetStaticBox();
49100 wxPyEndAllowThreads(__tstate);
49101 if (PyErr_Occurred()) SWIG_fail;
49102 }
49103 {
49104 resultobj = wxPyMake_wxObject(result, (bool)0);
49105 }
49106 return resultobj;
49107 fail:
49108 return NULL;
49109 }
49110
49111
49112 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49113 PyObject *obj;
49114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49115 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49116 return SWIG_Py_Void();
49117 }
49118
49119 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49120 return SWIG_Python_InitShadowInstance(args);
49121 }
49122
49123 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49124 PyObject *resultobj = 0;
49125 int arg1 = (int) 1 ;
49126 int arg2 = (int) 0 ;
49127 int arg3 = (int) 0 ;
49128 int arg4 = (int) 0 ;
49129 wxGridSizer *result = 0 ;
49130 int val1 ;
49131 int ecode1 = 0 ;
49132 int val2 ;
49133 int ecode2 = 0 ;
49134 int val3 ;
49135 int ecode3 = 0 ;
49136 int val4 ;
49137 int ecode4 = 0 ;
49138 PyObject * obj0 = 0 ;
49139 PyObject * obj1 = 0 ;
49140 PyObject * obj2 = 0 ;
49141 PyObject * obj3 = 0 ;
49142 char * kwnames[] = {
49143 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49144 };
49145
49146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49147 if (obj0) {
49148 ecode1 = SWIG_AsVal_int(obj0, &val1);
49149 if (!SWIG_IsOK(ecode1)) {
49150 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49151 }
49152 arg1 = static_cast< int >(val1);
49153 }
49154 if (obj1) {
49155 ecode2 = SWIG_AsVal_int(obj1, &val2);
49156 if (!SWIG_IsOK(ecode2)) {
49157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49158 }
49159 arg2 = static_cast< int >(val2);
49160 }
49161 if (obj2) {
49162 ecode3 = SWIG_AsVal_int(obj2, &val3);
49163 if (!SWIG_IsOK(ecode3)) {
49164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49165 }
49166 arg3 = static_cast< int >(val3);
49167 }
49168 if (obj3) {
49169 ecode4 = SWIG_AsVal_int(obj3, &val4);
49170 if (!SWIG_IsOK(ecode4)) {
49171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49172 }
49173 arg4 = static_cast< int >(val4);
49174 }
49175 {
49176 PyThreadState* __tstate = wxPyBeginAllowThreads();
49177 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49178 wxPyEndAllowThreads(__tstate);
49179 if (PyErr_Occurred()) SWIG_fail;
49180 }
49181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49182 return resultobj;
49183 fail:
49184 return NULL;
49185 }
49186
49187
49188 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49189 PyObject *resultobj = 0;
49190 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49191 int arg2 ;
49192 void *argp1 = 0 ;
49193 int res1 = 0 ;
49194 int val2 ;
49195 int ecode2 = 0 ;
49196 PyObject * obj0 = 0 ;
49197 PyObject * obj1 = 0 ;
49198 char * kwnames[] = {
49199 (char *) "self",(char *) "cols", NULL
49200 };
49201
49202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49204 if (!SWIG_IsOK(res1)) {
49205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49206 }
49207 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49208 ecode2 = SWIG_AsVal_int(obj1, &val2);
49209 if (!SWIG_IsOK(ecode2)) {
49210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49211 }
49212 arg2 = static_cast< int >(val2);
49213 {
49214 PyThreadState* __tstate = wxPyBeginAllowThreads();
49215 (arg1)->SetCols(arg2);
49216 wxPyEndAllowThreads(__tstate);
49217 if (PyErr_Occurred()) SWIG_fail;
49218 }
49219 resultobj = SWIG_Py_Void();
49220 return resultobj;
49221 fail:
49222 return NULL;
49223 }
49224
49225
49226 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49227 PyObject *resultobj = 0;
49228 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49229 int arg2 ;
49230 void *argp1 = 0 ;
49231 int res1 = 0 ;
49232 int val2 ;
49233 int ecode2 = 0 ;
49234 PyObject * obj0 = 0 ;
49235 PyObject * obj1 = 0 ;
49236 char * kwnames[] = {
49237 (char *) "self",(char *) "rows", NULL
49238 };
49239
49240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49242 if (!SWIG_IsOK(res1)) {
49243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49244 }
49245 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49246 ecode2 = SWIG_AsVal_int(obj1, &val2);
49247 if (!SWIG_IsOK(ecode2)) {
49248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49249 }
49250 arg2 = static_cast< int >(val2);
49251 {
49252 PyThreadState* __tstate = wxPyBeginAllowThreads();
49253 (arg1)->SetRows(arg2);
49254 wxPyEndAllowThreads(__tstate);
49255 if (PyErr_Occurred()) SWIG_fail;
49256 }
49257 resultobj = SWIG_Py_Void();
49258 return resultobj;
49259 fail:
49260 return NULL;
49261 }
49262
49263
49264 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49265 PyObject *resultobj = 0;
49266 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49267 int arg2 ;
49268 void *argp1 = 0 ;
49269 int res1 = 0 ;
49270 int val2 ;
49271 int ecode2 = 0 ;
49272 PyObject * obj0 = 0 ;
49273 PyObject * obj1 = 0 ;
49274 char * kwnames[] = {
49275 (char *) "self",(char *) "gap", NULL
49276 };
49277
49278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49280 if (!SWIG_IsOK(res1)) {
49281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49282 }
49283 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49284 ecode2 = SWIG_AsVal_int(obj1, &val2);
49285 if (!SWIG_IsOK(ecode2)) {
49286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49287 }
49288 arg2 = static_cast< int >(val2);
49289 {
49290 PyThreadState* __tstate = wxPyBeginAllowThreads();
49291 (arg1)->SetVGap(arg2);
49292 wxPyEndAllowThreads(__tstate);
49293 if (PyErr_Occurred()) SWIG_fail;
49294 }
49295 resultobj = SWIG_Py_Void();
49296 return resultobj;
49297 fail:
49298 return NULL;
49299 }
49300
49301
49302 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49303 PyObject *resultobj = 0;
49304 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49305 int arg2 ;
49306 void *argp1 = 0 ;
49307 int res1 = 0 ;
49308 int val2 ;
49309 int ecode2 = 0 ;
49310 PyObject * obj0 = 0 ;
49311 PyObject * obj1 = 0 ;
49312 char * kwnames[] = {
49313 (char *) "self",(char *) "gap", NULL
49314 };
49315
49316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49318 if (!SWIG_IsOK(res1)) {
49319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49320 }
49321 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49322 ecode2 = SWIG_AsVal_int(obj1, &val2);
49323 if (!SWIG_IsOK(ecode2)) {
49324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49325 }
49326 arg2 = static_cast< int >(val2);
49327 {
49328 PyThreadState* __tstate = wxPyBeginAllowThreads();
49329 (arg1)->SetHGap(arg2);
49330 wxPyEndAllowThreads(__tstate);
49331 if (PyErr_Occurred()) SWIG_fail;
49332 }
49333 resultobj = SWIG_Py_Void();
49334 return resultobj;
49335 fail:
49336 return NULL;
49337 }
49338
49339
49340 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49341 PyObject *resultobj = 0;
49342 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49343 int result;
49344 void *argp1 = 0 ;
49345 int res1 = 0 ;
49346 PyObject *swig_obj[1] ;
49347
49348 if (!args) SWIG_fail;
49349 swig_obj[0] = args;
49350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49351 if (!SWIG_IsOK(res1)) {
49352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49353 }
49354 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49355 {
49356 PyThreadState* __tstate = wxPyBeginAllowThreads();
49357 result = (int)(arg1)->GetCols();
49358 wxPyEndAllowThreads(__tstate);
49359 if (PyErr_Occurred()) SWIG_fail;
49360 }
49361 resultobj = SWIG_From_int(static_cast< int >(result));
49362 return resultobj;
49363 fail:
49364 return NULL;
49365 }
49366
49367
49368 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49369 PyObject *resultobj = 0;
49370 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49371 int result;
49372 void *argp1 = 0 ;
49373 int res1 = 0 ;
49374 PyObject *swig_obj[1] ;
49375
49376 if (!args) SWIG_fail;
49377 swig_obj[0] = args;
49378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49379 if (!SWIG_IsOK(res1)) {
49380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49381 }
49382 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49383 {
49384 PyThreadState* __tstate = wxPyBeginAllowThreads();
49385 result = (int)(arg1)->GetRows();
49386 wxPyEndAllowThreads(__tstate);
49387 if (PyErr_Occurred()) SWIG_fail;
49388 }
49389 resultobj = SWIG_From_int(static_cast< int >(result));
49390 return resultobj;
49391 fail:
49392 return NULL;
49393 }
49394
49395
49396 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49397 PyObject *resultobj = 0;
49398 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49399 int result;
49400 void *argp1 = 0 ;
49401 int res1 = 0 ;
49402 PyObject *swig_obj[1] ;
49403
49404 if (!args) SWIG_fail;
49405 swig_obj[0] = args;
49406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49407 if (!SWIG_IsOK(res1)) {
49408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49409 }
49410 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49411 {
49412 PyThreadState* __tstate = wxPyBeginAllowThreads();
49413 result = (int)(arg1)->GetVGap();
49414 wxPyEndAllowThreads(__tstate);
49415 if (PyErr_Occurred()) SWIG_fail;
49416 }
49417 resultobj = SWIG_From_int(static_cast< int >(result));
49418 return resultobj;
49419 fail:
49420 return NULL;
49421 }
49422
49423
49424 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49425 PyObject *resultobj = 0;
49426 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49427 int result;
49428 void *argp1 = 0 ;
49429 int res1 = 0 ;
49430 PyObject *swig_obj[1] ;
49431
49432 if (!args) SWIG_fail;
49433 swig_obj[0] = args;
49434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49435 if (!SWIG_IsOK(res1)) {
49436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49437 }
49438 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49439 {
49440 PyThreadState* __tstate = wxPyBeginAllowThreads();
49441 result = (int)(arg1)->GetHGap();
49442 wxPyEndAllowThreads(__tstate);
49443 if (PyErr_Occurred()) SWIG_fail;
49444 }
49445 resultobj = SWIG_From_int(static_cast< int >(result));
49446 return resultobj;
49447 fail:
49448 return NULL;
49449 }
49450
49451
49452 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49453 PyObject *obj;
49454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49455 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49456 return SWIG_Py_Void();
49457 }
49458
49459 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49460 return SWIG_Python_InitShadowInstance(args);
49461 }
49462
49463 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49464 PyObject *resultobj = 0;
49465 int arg1 = (int) 1 ;
49466 int arg2 = (int) 0 ;
49467 int arg3 = (int) 0 ;
49468 int arg4 = (int) 0 ;
49469 wxFlexGridSizer *result = 0 ;
49470 int val1 ;
49471 int ecode1 = 0 ;
49472 int val2 ;
49473 int ecode2 = 0 ;
49474 int val3 ;
49475 int ecode3 = 0 ;
49476 int val4 ;
49477 int ecode4 = 0 ;
49478 PyObject * obj0 = 0 ;
49479 PyObject * obj1 = 0 ;
49480 PyObject * obj2 = 0 ;
49481 PyObject * obj3 = 0 ;
49482 char * kwnames[] = {
49483 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49484 };
49485
49486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49487 if (obj0) {
49488 ecode1 = SWIG_AsVal_int(obj0, &val1);
49489 if (!SWIG_IsOK(ecode1)) {
49490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49491 }
49492 arg1 = static_cast< int >(val1);
49493 }
49494 if (obj1) {
49495 ecode2 = SWIG_AsVal_int(obj1, &val2);
49496 if (!SWIG_IsOK(ecode2)) {
49497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49498 }
49499 arg2 = static_cast< int >(val2);
49500 }
49501 if (obj2) {
49502 ecode3 = SWIG_AsVal_int(obj2, &val3);
49503 if (!SWIG_IsOK(ecode3)) {
49504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49505 }
49506 arg3 = static_cast< int >(val3);
49507 }
49508 if (obj3) {
49509 ecode4 = SWIG_AsVal_int(obj3, &val4);
49510 if (!SWIG_IsOK(ecode4)) {
49511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49512 }
49513 arg4 = static_cast< int >(val4);
49514 }
49515 {
49516 PyThreadState* __tstate = wxPyBeginAllowThreads();
49517 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49522 return resultobj;
49523 fail:
49524 return NULL;
49525 }
49526
49527
49528 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49529 PyObject *resultobj = 0;
49530 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49531 size_t arg2 ;
49532 int arg3 = (int) 0 ;
49533 void *argp1 = 0 ;
49534 int res1 = 0 ;
49535 size_t val2 ;
49536 int ecode2 = 0 ;
49537 int val3 ;
49538 int ecode3 = 0 ;
49539 PyObject * obj0 = 0 ;
49540 PyObject * obj1 = 0 ;
49541 PyObject * obj2 = 0 ;
49542 char * kwnames[] = {
49543 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49544 };
49545
49546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49548 if (!SWIG_IsOK(res1)) {
49549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49550 }
49551 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49552 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49553 if (!SWIG_IsOK(ecode2)) {
49554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49555 }
49556 arg2 = static_cast< size_t >(val2);
49557 if (obj2) {
49558 ecode3 = SWIG_AsVal_int(obj2, &val3);
49559 if (!SWIG_IsOK(ecode3)) {
49560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49561 }
49562 arg3 = static_cast< int >(val3);
49563 }
49564 {
49565 PyThreadState* __tstate = wxPyBeginAllowThreads();
49566 (arg1)->AddGrowableRow(arg2,arg3);
49567 wxPyEndAllowThreads(__tstate);
49568 if (PyErr_Occurred()) SWIG_fail;
49569 }
49570 resultobj = SWIG_Py_Void();
49571 return resultobj;
49572 fail:
49573 return NULL;
49574 }
49575
49576
49577 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49578 PyObject *resultobj = 0;
49579 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49580 size_t arg2 ;
49581 void *argp1 = 0 ;
49582 int res1 = 0 ;
49583 size_t val2 ;
49584 int ecode2 = 0 ;
49585 PyObject * obj0 = 0 ;
49586 PyObject * obj1 = 0 ;
49587 char * kwnames[] = {
49588 (char *) "self",(char *) "idx", NULL
49589 };
49590
49591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49593 if (!SWIG_IsOK(res1)) {
49594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49595 }
49596 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49597 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49598 if (!SWIG_IsOK(ecode2)) {
49599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49600 }
49601 arg2 = static_cast< size_t >(val2);
49602 {
49603 PyThreadState* __tstate = wxPyBeginAllowThreads();
49604 (arg1)->RemoveGrowableRow(arg2);
49605 wxPyEndAllowThreads(__tstate);
49606 if (PyErr_Occurred()) SWIG_fail;
49607 }
49608 resultobj = SWIG_Py_Void();
49609 return resultobj;
49610 fail:
49611 return NULL;
49612 }
49613
49614
49615 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49616 PyObject *resultobj = 0;
49617 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49618 size_t arg2 ;
49619 int arg3 = (int) 0 ;
49620 void *argp1 = 0 ;
49621 int res1 = 0 ;
49622 size_t val2 ;
49623 int ecode2 = 0 ;
49624 int val3 ;
49625 int ecode3 = 0 ;
49626 PyObject * obj0 = 0 ;
49627 PyObject * obj1 = 0 ;
49628 PyObject * obj2 = 0 ;
49629 char * kwnames[] = {
49630 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49631 };
49632
49633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49635 if (!SWIG_IsOK(res1)) {
49636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49637 }
49638 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49639 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49640 if (!SWIG_IsOK(ecode2)) {
49641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49642 }
49643 arg2 = static_cast< size_t >(val2);
49644 if (obj2) {
49645 ecode3 = SWIG_AsVal_int(obj2, &val3);
49646 if (!SWIG_IsOK(ecode3)) {
49647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49648 }
49649 arg3 = static_cast< int >(val3);
49650 }
49651 {
49652 PyThreadState* __tstate = wxPyBeginAllowThreads();
49653 (arg1)->AddGrowableCol(arg2,arg3);
49654 wxPyEndAllowThreads(__tstate);
49655 if (PyErr_Occurred()) SWIG_fail;
49656 }
49657 resultobj = SWIG_Py_Void();
49658 return resultobj;
49659 fail:
49660 return NULL;
49661 }
49662
49663
49664 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49665 PyObject *resultobj = 0;
49666 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49667 size_t arg2 ;
49668 void *argp1 = 0 ;
49669 int res1 = 0 ;
49670 size_t val2 ;
49671 int ecode2 = 0 ;
49672 PyObject * obj0 = 0 ;
49673 PyObject * obj1 = 0 ;
49674 char * kwnames[] = {
49675 (char *) "self",(char *) "idx", NULL
49676 };
49677
49678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49680 if (!SWIG_IsOK(res1)) {
49681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49682 }
49683 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49685 if (!SWIG_IsOK(ecode2)) {
49686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49687 }
49688 arg2 = static_cast< size_t >(val2);
49689 {
49690 PyThreadState* __tstate = wxPyBeginAllowThreads();
49691 (arg1)->RemoveGrowableCol(arg2);
49692 wxPyEndAllowThreads(__tstate);
49693 if (PyErr_Occurred()) SWIG_fail;
49694 }
49695 resultobj = SWIG_Py_Void();
49696 return resultobj;
49697 fail:
49698 return NULL;
49699 }
49700
49701
49702 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49703 PyObject *resultobj = 0;
49704 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49705 int arg2 ;
49706 void *argp1 = 0 ;
49707 int res1 = 0 ;
49708 int val2 ;
49709 int ecode2 = 0 ;
49710 PyObject * obj0 = 0 ;
49711 PyObject * obj1 = 0 ;
49712 char * kwnames[] = {
49713 (char *) "self",(char *) "direction", NULL
49714 };
49715
49716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49718 if (!SWIG_IsOK(res1)) {
49719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49720 }
49721 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49722 ecode2 = SWIG_AsVal_int(obj1, &val2);
49723 if (!SWIG_IsOK(ecode2)) {
49724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49725 }
49726 arg2 = static_cast< int >(val2);
49727 {
49728 PyThreadState* __tstate = wxPyBeginAllowThreads();
49729 (arg1)->SetFlexibleDirection(arg2);
49730 wxPyEndAllowThreads(__tstate);
49731 if (PyErr_Occurred()) SWIG_fail;
49732 }
49733 resultobj = SWIG_Py_Void();
49734 return resultobj;
49735 fail:
49736 return NULL;
49737 }
49738
49739
49740 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49741 PyObject *resultobj = 0;
49742 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49743 int result;
49744 void *argp1 = 0 ;
49745 int res1 = 0 ;
49746 PyObject *swig_obj[1] ;
49747
49748 if (!args) SWIG_fail;
49749 swig_obj[0] = args;
49750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49751 if (!SWIG_IsOK(res1)) {
49752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49753 }
49754 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49755 {
49756 PyThreadState* __tstate = wxPyBeginAllowThreads();
49757 result = (int)(arg1)->GetFlexibleDirection();
49758 wxPyEndAllowThreads(__tstate);
49759 if (PyErr_Occurred()) SWIG_fail;
49760 }
49761 resultobj = SWIG_From_int(static_cast< int >(result));
49762 return resultobj;
49763 fail:
49764 return NULL;
49765 }
49766
49767
49768 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49769 PyObject *resultobj = 0;
49770 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49771 wxFlexSizerGrowMode arg2 ;
49772 void *argp1 = 0 ;
49773 int res1 = 0 ;
49774 int val2 ;
49775 int ecode2 = 0 ;
49776 PyObject * obj0 = 0 ;
49777 PyObject * obj1 = 0 ;
49778 char * kwnames[] = {
49779 (char *) "self",(char *) "mode", NULL
49780 };
49781
49782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49784 if (!SWIG_IsOK(res1)) {
49785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49786 }
49787 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49788 ecode2 = SWIG_AsVal_int(obj1, &val2);
49789 if (!SWIG_IsOK(ecode2)) {
49790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49791 }
49792 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49793 {
49794 PyThreadState* __tstate = wxPyBeginAllowThreads();
49795 (arg1)->SetNonFlexibleGrowMode(arg2);
49796 wxPyEndAllowThreads(__tstate);
49797 if (PyErr_Occurred()) SWIG_fail;
49798 }
49799 resultobj = SWIG_Py_Void();
49800 return resultobj;
49801 fail:
49802 return NULL;
49803 }
49804
49805
49806 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49807 PyObject *resultobj = 0;
49808 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49809 wxFlexSizerGrowMode result;
49810 void *argp1 = 0 ;
49811 int res1 = 0 ;
49812 PyObject *swig_obj[1] ;
49813
49814 if (!args) SWIG_fail;
49815 swig_obj[0] = args;
49816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49817 if (!SWIG_IsOK(res1)) {
49818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49819 }
49820 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49821 {
49822 PyThreadState* __tstate = wxPyBeginAllowThreads();
49823 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49824 wxPyEndAllowThreads(__tstate);
49825 if (PyErr_Occurred()) SWIG_fail;
49826 }
49827 resultobj = SWIG_From_int(static_cast< int >(result));
49828 return resultobj;
49829 fail:
49830 return NULL;
49831 }
49832
49833
49834 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49835 PyObject *resultobj = 0;
49836 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49837 wxArrayInt *result = 0 ;
49838 void *argp1 = 0 ;
49839 int res1 = 0 ;
49840 PyObject *swig_obj[1] ;
49841
49842 if (!args) SWIG_fail;
49843 swig_obj[0] = args;
49844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49845 if (!SWIG_IsOK(res1)) {
49846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49847 }
49848 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49849 {
49850 PyThreadState* __tstate = wxPyBeginAllowThreads();
49851 {
49852 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49853 result = (wxArrayInt *) &_result_ref;
49854 }
49855 wxPyEndAllowThreads(__tstate);
49856 if (PyErr_Occurred()) SWIG_fail;
49857 }
49858 {
49859 resultobj = PyList_New(0);
49860 size_t idx;
49861 for (idx = 0; idx < result->GetCount(); idx += 1) {
49862 PyObject* val = PyInt_FromLong( result->Item(idx) );
49863 PyList_Append(resultobj, val);
49864 Py_DECREF(val);
49865 }
49866 }
49867 return resultobj;
49868 fail:
49869 return NULL;
49870 }
49871
49872
49873 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49874 PyObject *resultobj = 0;
49875 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49876 wxArrayInt *result = 0 ;
49877 void *argp1 = 0 ;
49878 int res1 = 0 ;
49879 PyObject *swig_obj[1] ;
49880
49881 if (!args) SWIG_fail;
49882 swig_obj[0] = args;
49883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49884 if (!SWIG_IsOK(res1)) {
49885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49886 }
49887 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49888 {
49889 PyThreadState* __tstate = wxPyBeginAllowThreads();
49890 {
49891 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49892 result = (wxArrayInt *) &_result_ref;
49893 }
49894 wxPyEndAllowThreads(__tstate);
49895 if (PyErr_Occurred()) SWIG_fail;
49896 }
49897 {
49898 resultobj = PyList_New(0);
49899 size_t idx;
49900 for (idx = 0; idx < result->GetCount(); idx += 1) {
49901 PyObject* val = PyInt_FromLong( result->Item(idx) );
49902 PyList_Append(resultobj, val);
49903 Py_DECREF(val);
49904 }
49905 }
49906 return resultobj;
49907 fail:
49908 return NULL;
49909 }
49910
49911
49912 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49913 PyObject *obj;
49914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49915 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49916 return SWIG_Py_Void();
49917 }
49918
49919 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49920 return SWIG_Python_InitShadowInstance(args);
49921 }
49922
49923 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49924 PyObject *resultobj = 0;
49925 wxStdDialogButtonSizer *result = 0 ;
49926
49927 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49928 {
49929 PyThreadState* __tstate = wxPyBeginAllowThreads();
49930 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49931 wxPyEndAllowThreads(__tstate);
49932 if (PyErr_Occurred()) SWIG_fail;
49933 }
49934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49935 return resultobj;
49936 fail:
49937 return NULL;
49938 }
49939
49940
49941 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49942 PyObject *resultobj = 0;
49943 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49944 wxButton *arg2 = (wxButton *) 0 ;
49945 void *argp1 = 0 ;
49946 int res1 = 0 ;
49947 void *argp2 = 0 ;
49948 int res2 = 0 ;
49949 PyObject * obj0 = 0 ;
49950 PyObject * obj1 = 0 ;
49951 char * kwnames[] = {
49952 (char *) "self",(char *) "button", NULL
49953 };
49954
49955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49957 if (!SWIG_IsOK(res1)) {
49958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49959 }
49960 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49962 if (!SWIG_IsOK(res2)) {
49963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49964 }
49965 arg2 = reinterpret_cast< wxButton * >(argp2);
49966 {
49967 PyThreadState* __tstate = wxPyBeginAllowThreads();
49968 (arg1)->AddButton(arg2);
49969 wxPyEndAllowThreads(__tstate);
49970 if (PyErr_Occurred()) SWIG_fail;
49971 }
49972 resultobj = SWIG_Py_Void();
49973 return resultobj;
49974 fail:
49975 return NULL;
49976 }
49977
49978
49979 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49980 PyObject *resultobj = 0;
49981 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49982 void *argp1 = 0 ;
49983 int res1 = 0 ;
49984 PyObject *swig_obj[1] ;
49985
49986 if (!args) SWIG_fail;
49987 swig_obj[0] = args;
49988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49989 if (!SWIG_IsOK(res1)) {
49990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49991 }
49992 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49993 {
49994 PyThreadState* __tstate = wxPyBeginAllowThreads();
49995 (arg1)->Realize();
49996 wxPyEndAllowThreads(__tstate);
49997 if (PyErr_Occurred()) SWIG_fail;
49998 }
49999 resultobj = SWIG_Py_Void();
50000 return resultobj;
50001 fail:
50002 return NULL;
50003 }
50004
50005
50006 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50007 PyObject *resultobj = 0;
50008 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50009 wxButton *arg2 = (wxButton *) 0 ;
50010 void *argp1 = 0 ;
50011 int res1 = 0 ;
50012 void *argp2 = 0 ;
50013 int res2 = 0 ;
50014 PyObject * obj0 = 0 ;
50015 PyObject * obj1 = 0 ;
50016 char * kwnames[] = {
50017 (char *) "self",(char *) "button", NULL
50018 };
50019
50020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50022 if (!SWIG_IsOK(res1)) {
50023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50024 }
50025 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50026 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50027 if (!SWIG_IsOK(res2)) {
50028 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50029 }
50030 arg2 = reinterpret_cast< wxButton * >(argp2);
50031 {
50032 PyThreadState* __tstate = wxPyBeginAllowThreads();
50033 (arg1)->SetAffirmativeButton(arg2);
50034 wxPyEndAllowThreads(__tstate);
50035 if (PyErr_Occurred()) SWIG_fail;
50036 }
50037 resultobj = SWIG_Py_Void();
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50045 PyObject *resultobj = 0;
50046 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50047 wxButton *arg2 = (wxButton *) 0 ;
50048 void *argp1 = 0 ;
50049 int res1 = 0 ;
50050 void *argp2 = 0 ;
50051 int res2 = 0 ;
50052 PyObject * obj0 = 0 ;
50053 PyObject * obj1 = 0 ;
50054 char * kwnames[] = {
50055 (char *) "self",(char *) "button", NULL
50056 };
50057
50058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50060 if (!SWIG_IsOK(res1)) {
50061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50062 }
50063 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50064 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50065 if (!SWIG_IsOK(res2)) {
50066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50067 }
50068 arg2 = reinterpret_cast< wxButton * >(argp2);
50069 {
50070 PyThreadState* __tstate = wxPyBeginAllowThreads();
50071 (arg1)->SetNegativeButton(arg2);
50072 wxPyEndAllowThreads(__tstate);
50073 if (PyErr_Occurred()) SWIG_fail;
50074 }
50075 resultobj = SWIG_Py_Void();
50076 return resultobj;
50077 fail:
50078 return NULL;
50079 }
50080
50081
50082 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50083 PyObject *resultobj = 0;
50084 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50085 wxButton *arg2 = (wxButton *) 0 ;
50086 void *argp1 = 0 ;
50087 int res1 = 0 ;
50088 void *argp2 = 0 ;
50089 int res2 = 0 ;
50090 PyObject * obj0 = 0 ;
50091 PyObject * obj1 = 0 ;
50092 char * kwnames[] = {
50093 (char *) "self",(char *) "button", NULL
50094 };
50095
50096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50098 if (!SWIG_IsOK(res1)) {
50099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50100 }
50101 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50103 if (!SWIG_IsOK(res2)) {
50104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50105 }
50106 arg2 = reinterpret_cast< wxButton * >(argp2);
50107 {
50108 PyThreadState* __tstate = wxPyBeginAllowThreads();
50109 (arg1)->SetCancelButton(arg2);
50110 wxPyEndAllowThreads(__tstate);
50111 if (PyErr_Occurred()) SWIG_fail;
50112 }
50113 resultobj = SWIG_Py_Void();
50114 return resultobj;
50115 fail:
50116 return NULL;
50117 }
50118
50119
50120 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50121 PyObject *resultobj = 0;
50122 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50123 wxButton *result = 0 ;
50124 void *argp1 = 0 ;
50125 int res1 = 0 ;
50126 PyObject *swig_obj[1] ;
50127
50128 if (!args) SWIG_fail;
50129 swig_obj[0] = args;
50130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50131 if (!SWIG_IsOK(res1)) {
50132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50133 }
50134 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50135 {
50136 PyThreadState* __tstate = wxPyBeginAllowThreads();
50137 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50138 wxPyEndAllowThreads(__tstate);
50139 if (PyErr_Occurred()) SWIG_fail;
50140 }
50141 {
50142 resultobj = wxPyMake_wxObject(result, (bool)0);
50143 }
50144 return resultobj;
50145 fail:
50146 return NULL;
50147 }
50148
50149
50150 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50151 PyObject *resultobj = 0;
50152 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50153 wxButton *result = 0 ;
50154 void *argp1 = 0 ;
50155 int res1 = 0 ;
50156 PyObject *swig_obj[1] ;
50157
50158 if (!args) SWIG_fail;
50159 swig_obj[0] = args;
50160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50161 if (!SWIG_IsOK(res1)) {
50162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50163 }
50164 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50165 {
50166 PyThreadState* __tstate = wxPyBeginAllowThreads();
50167 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50168 wxPyEndAllowThreads(__tstate);
50169 if (PyErr_Occurred()) SWIG_fail;
50170 }
50171 {
50172 resultobj = wxPyMake_wxObject(result, (bool)0);
50173 }
50174 return resultobj;
50175 fail:
50176 return NULL;
50177 }
50178
50179
50180 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50181 PyObject *resultobj = 0;
50182 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50183 wxButton *result = 0 ;
50184 void *argp1 = 0 ;
50185 int res1 = 0 ;
50186 PyObject *swig_obj[1] ;
50187
50188 if (!args) SWIG_fail;
50189 swig_obj[0] = args;
50190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50191 if (!SWIG_IsOK(res1)) {
50192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50193 }
50194 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50195 {
50196 PyThreadState* __tstate = wxPyBeginAllowThreads();
50197 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50198 wxPyEndAllowThreads(__tstate);
50199 if (PyErr_Occurred()) SWIG_fail;
50200 }
50201 {
50202 resultobj = wxPyMake_wxObject(result, (bool)0);
50203 }
50204 return resultobj;
50205 fail:
50206 return NULL;
50207 }
50208
50209
50210 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50211 PyObject *resultobj = 0;
50212 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50213 wxButton *result = 0 ;
50214 void *argp1 = 0 ;
50215 int res1 = 0 ;
50216 PyObject *swig_obj[1] ;
50217
50218 if (!args) SWIG_fail;
50219 swig_obj[0] = args;
50220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50221 if (!SWIG_IsOK(res1)) {
50222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50223 }
50224 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50225 {
50226 PyThreadState* __tstate = wxPyBeginAllowThreads();
50227 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50228 wxPyEndAllowThreads(__tstate);
50229 if (PyErr_Occurred()) SWIG_fail;
50230 }
50231 {
50232 resultobj = wxPyMake_wxObject(result, (bool)0);
50233 }
50234 return resultobj;
50235 fail:
50236 return NULL;
50237 }
50238
50239
50240 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50241 PyObject *resultobj = 0;
50242 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50243 wxButton *result = 0 ;
50244 void *argp1 = 0 ;
50245 int res1 = 0 ;
50246 PyObject *swig_obj[1] ;
50247
50248 if (!args) SWIG_fail;
50249 swig_obj[0] = args;
50250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50251 if (!SWIG_IsOK(res1)) {
50252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50253 }
50254 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50255 {
50256 PyThreadState* __tstate = wxPyBeginAllowThreads();
50257 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50258 wxPyEndAllowThreads(__tstate);
50259 if (PyErr_Occurred()) SWIG_fail;
50260 }
50261 {
50262 resultobj = wxPyMake_wxObject(result, (bool)0);
50263 }
50264 return resultobj;
50265 fail:
50266 return NULL;
50267 }
50268
50269
50270 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50271 PyObject *obj;
50272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50273 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50274 return SWIG_Py_Void();
50275 }
50276
50277 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50278 return SWIG_Python_InitShadowInstance(args);
50279 }
50280
50281 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50282 PyObject *resultobj = 0;
50283 int arg1 = (int) 0 ;
50284 int arg2 = (int) 0 ;
50285 wxGBPosition *result = 0 ;
50286 int val1 ;
50287 int ecode1 = 0 ;
50288 int val2 ;
50289 int ecode2 = 0 ;
50290 PyObject * obj0 = 0 ;
50291 PyObject * obj1 = 0 ;
50292 char * kwnames[] = {
50293 (char *) "row",(char *) "col", NULL
50294 };
50295
50296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50297 if (obj0) {
50298 ecode1 = SWIG_AsVal_int(obj0, &val1);
50299 if (!SWIG_IsOK(ecode1)) {
50300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50301 }
50302 arg1 = static_cast< int >(val1);
50303 }
50304 if (obj1) {
50305 ecode2 = SWIG_AsVal_int(obj1, &val2);
50306 if (!SWIG_IsOK(ecode2)) {
50307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50308 }
50309 arg2 = static_cast< int >(val2);
50310 }
50311 {
50312 PyThreadState* __tstate = wxPyBeginAllowThreads();
50313 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50314 wxPyEndAllowThreads(__tstate);
50315 if (PyErr_Occurred()) SWIG_fail;
50316 }
50317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50318 return resultobj;
50319 fail:
50320 return NULL;
50321 }
50322
50323
50324 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50325 PyObject *resultobj = 0;
50326 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50327 void *argp1 = 0 ;
50328 int res1 = 0 ;
50329 PyObject *swig_obj[1] ;
50330
50331 if (!args) SWIG_fail;
50332 swig_obj[0] = args;
50333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50334 if (!SWIG_IsOK(res1)) {
50335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50336 }
50337 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50338 {
50339 PyThreadState* __tstate = wxPyBeginAllowThreads();
50340 delete arg1;
50341
50342 wxPyEndAllowThreads(__tstate);
50343 if (PyErr_Occurred()) SWIG_fail;
50344 }
50345 resultobj = SWIG_Py_Void();
50346 return resultobj;
50347 fail:
50348 return NULL;
50349 }
50350
50351
50352 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50353 PyObject *resultobj = 0;
50354 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50355 int result;
50356 void *argp1 = 0 ;
50357 int res1 = 0 ;
50358 PyObject *swig_obj[1] ;
50359
50360 if (!args) SWIG_fail;
50361 swig_obj[0] = args;
50362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50363 if (!SWIG_IsOK(res1)) {
50364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50365 }
50366 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50367 {
50368 PyThreadState* __tstate = wxPyBeginAllowThreads();
50369 result = (int)((wxGBPosition const *)arg1)->GetRow();
50370 wxPyEndAllowThreads(__tstate);
50371 if (PyErr_Occurred()) SWIG_fail;
50372 }
50373 resultobj = SWIG_From_int(static_cast< int >(result));
50374 return resultobj;
50375 fail:
50376 return NULL;
50377 }
50378
50379
50380 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50381 PyObject *resultobj = 0;
50382 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50383 int result;
50384 void *argp1 = 0 ;
50385 int res1 = 0 ;
50386 PyObject *swig_obj[1] ;
50387
50388 if (!args) SWIG_fail;
50389 swig_obj[0] = args;
50390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50391 if (!SWIG_IsOK(res1)) {
50392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50393 }
50394 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50395 {
50396 PyThreadState* __tstate = wxPyBeginAllowThreads();
50397 result = (int)((wxGBPosition const *)arg1)->GetCol();
50398 wxPyEndAllowThreads(__tstate);
50399 if (PyErr_Occurred()) SWIG_fail;
50400 }
50401 resultobj = SWIG_From_int(static_cast< int >(result));
50402 return resultobj;
50403 fail:
50404 return NULL;
50405 }
50406
50407
50408 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50409 PyObject *resultobj = 0;
50410 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50411 int arg2 ;
50412 void *argp1 = 0 ;
50413 int res1 = 0 ;
50414 int val2 ;
50415 int ecode2 = 0 ;
50416 PyObject * obj0 = 0 ;
50417 PyObject * obj1 = 0 ;
50418 char * kwnames[] = {
50419 (char *) "self",(char *) "row", NULL
50420 };
50421
50422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50428 ecode2 = SWIG_AsVal_int(obj1, &val2);
50429 if (!SWIG_IsOK(ecode2)) {
50430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50431 }
50432 arg2 = static_cast< int >(val2);
50433 {
50434 PyThreadState* __tstate = wxPyBeginAllowThreads();
50435 (arg1)->SetRow(arg2);
50436 wxPyEndAllowThreads(__tstate);
50437 if (PyErr_Occurred()) SWIG_fail;
50438 }
50439 resultobj = SWIG_Py_Void();
50440 return resultobj;
50441 fail:
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50447 PyObject *resultobj = 0;
50448 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50449 int arg2 ;
50450 void *argp1 = 0 ;
50451 int res1 = 0 ;
50452 int val2 ;
50453 int ecode2 = 0 ;
50454 PyObject * obj0 = 0 ;
50455 PyObject * obj1 = 0 ;
50456 char * kwnames[] = {
50457 (char *) "self",(char *) "col", NULL
50458 };
50459
50460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50462 if (!SWIG_IsOK(res1)) {
50463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50464 }
50465 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50466 ecode2 = SWIG_AsVal_int(obj1, &val2);
50467 if (!SWIG_IsOK(ecode2)) {
50468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50469 }
50470 arg2 = static_cast< int >(val2);
50471 {
50472 PyThreadState* __tstate = wxPyBeginAllowThreads();
50473 (arg1)->SetCol(arg2);
50474 wxPyEndAllowThreads(__tstate);
50475 if (PyErr_Occurred()) SWIG_fail;
50476 }
50477 resultobj = SWIG_Py_Void();
50478 return resultobj;
50479 fail:
50480 return NULL;
50481 }
50482
50483
50484 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50485 PyObject *resultobj = 0;
50486 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50487 PyObject *arg2 = (PyObject *) 0 ;
50488 bool result;
50489 void *argp1 = 0 ;
50490 int res1 = 0 ;
50491 PyObject * obj0 = 0 ;
50492 PyObject * obj1 = 0 ;
50493 char * kwnames[] = {
50494 (char *) "self",(char *) "other", NULL
50495 };
50496
50497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50499 if (!SWIG_IsOK(res1)) {
50500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50501 }
50502 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50503 arg2 = obj1;
50504 {
50505 result = (bool)wxGBPosition___eq__(arg1,arg2);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 {
50509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50510 }
50511 return resultobj;
50512 fail:
50513 return NULL;
50514 }
50515
50516
50517 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50518 PyObject *resultobj = 0;
50519 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50520 PyObject *arg2 = (PyObject *) 0 ;
50521 bool result;
50522 void *argp1 = 0 ;
50523 int res1 = 0 ;
50524 PyObject * obj0 = 0 ;
50525 PyObject * obj1 = 0 ;
50526 char * kwnames[] = {
50527 (char *) "self",(char *) "other", NULL
50528 };
50529
50530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50532 if (!SWIG_IsOK(res1)) {
50533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50534 }
50535 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50536 arg2 = obj1;
50537 {
50538 result = (bool)wxGBPosition___ne__(arg1,arg2);
50539 if (PyErr_Occurred()) SWIG_fail;
50540 }
50541 {
50542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50543 }
50544 return resultobj;
50545 fail:
50546 return NULL;
50547 }
50548
50549
50550 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50551 PyObject *resultobj = 0;
50552 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50553 int arg2 = (int) 0 ;
50554 int arg3 = (int) 0 ;
50555 void *argp1 = 0 ;
50556 int res1 = 0 ;
50557 int val2 ;
50558 int ecode2 = 0 ;
50559 int val3 ;
50560 int ecode3 = 0 ;
50561 PyObject * obj0 = 0 ;
50562 PyObject * obj1 = 0 ;
50563 PyObject * obj2 = 0 ;
50564 char * kwnames[] = {
50565 (char *) "self",(char *) "row",(char *) "col", NULL
50566 };
50567
50568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50570 if (!SWIG_IsOK(res1)) {
50571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50572 }
50573 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50574 if (obj1) {
50575 ecode2 = SWIG_AsVal_int(obj1, &val2);
50576 if (!SWIG_IsOK(ecode2)) {
50577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50578 }
50579 arg2 = static_cast< int >(val2);
50580 }
50581 if (obj2) {
50582 ecode3 = SWIG_AsVal_int(obj2, &val3);
50583 if (!SWIG_IsOK(ecode3)) {
50584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50585 }
50586 arg3 = static_cast< int >(val3);
50587 }
50588 {
50589 PyThreadState* __tstate = wxPyBeginAllowThreads();
50590 wxGBPosition_Set(arg1,arg2,arg3);
50591 wxPyEndAllowThreads(__tstate);
50592 if (PyErr_Occurred()) SWIG_fail;
50593 }
50594 resultobj = SWIG_Py_Void();
50595 return resultobj;
50596 fail:
50597 return NULL;
50598 }
50599
50600
50601 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50602 PyObject *resultobj = 0;
50603 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50604 PyObject *result = 0 ;
50605 void *argp1 = 0 ;
50606 int res1 = 0 ;
50607 PyObject *swig_obj[1] ;
50608
50609 if (!args) SWIG_fail;
50610 swig_obj[0] = args;
50611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50612 if (!SWIG_IsOK(res1)) {
50613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50614 }
50615 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50616 {
50617 PyThreadState* __tstate = wxPyBeginAllowThreads();
50618 result = (PyObject *)wxGBPosition_Get(arg1);
50619 wxPyEndAllowThreads(__tstate);
50620 if (PyErr_Occurred()) SWIG_fail;
50621 }
50622 resultobj = result;
50623 return resultobj;
50624 fail:
50625 return NULL;
50626 }
50627
50628
50629 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50630 PyObject *obj;
50631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50632 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50633 return SWIG_Py_Void();
50634 }
50635
50636 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50637 return SWIG_Python_InitShadowInstance(args);
50638 }
50639
50640 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50641 PyObject *resultobj = 0;
50642 int arg1 = (int) 1 ;
50643 int arg2 = (int) 1 ;
50644 wxGBSpan *result = 0 ;
50645 int val1 ;
50646 int ecode1 = 0 ;
50647 int val2 ;
50648 int ecode2 = 0 ;
50649 PyObject * obj0 = 0 ;
50650 PyObject * obj1 = 0 ;
50651 char * kwnames[] = {
50652 (char *) "rowspan",(char *) "colspan", NULL
50653 };
50654
50655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50656 if (obj0) {
50657 ecode1 = SWIG_AsVal_int(obj0, &val1);
50658 if (!SWIG_IsOK(ecode1)) {
50659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50660 }
50661 arg1 = static_cast< int >(val1);
50662 }
50663 if (obj1) {
50664 ecode2 = SWIG_AsVal_int(obj1, &val2);
50665 if (!SWIG_IsOK(ecode2)) {
50666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50667 }
50668 arg2 = static_cast< int >(val2);
50669 }
50670 {
50671 PyThreadState* __tstate = wxPyBeginAllowThreads();
50672 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50673 wxPyEndAllowThreads(__tstate);
50674 if (PyErr_Occurred()) SWIG_fail;
50675 }
50676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50677 return resultobj;
50678 fail:
50679 return NULL;
50680 }
50681
50682
50683 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50684 PyObject *resultobj = 0;
50685 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50686 void *argp1 = 0 ;
50687 int res1 = 0 ;
50688 PyObject *swig_obj[1] ;
50689
50690 if (!args) SWIG_fail;
50691 swig_obj[0] = args;
50692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50693 if (!SWIG_IsOK(res1)) {
50694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50695 }
50696 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50697 {
50698 PyThreadState* __tstate = wxPyBeginAllowThreads();
50699 delete arg1;
50700
50701 wxPyEndAllowThreads(__tstate);
50702 if (PyErr_Occurred()) SWIG_fail;
50703 }
50704 resultobj = SWIG_Py_Void();
50705 return resultobj;
50706 fail:
50707 return NULL;
50708 }
50709
50710
50711 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50712 PyObject *resultobj = 0;
50713 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50714 int result;
50715 void *argp1 = 0 ;
50716 int res1 = 0 ;
50717 PyObject *swig_obj[1] ;
50718
50719 if (!args) SWIG_fail;
50720 swig_obj[0] = args;
50721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50722 if (!SWIG_IsOK(res1)) {
50723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50724 }
50725 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50726 {
50727 PyThreadState* __tstate = wxPyBeginAllowThreads();
50728 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50729 wxPyEndAllowThreads(__tstate);
50730 if (PyErr_Occurred()) SWIG_fail;
50731 }
50732 resultobj = SWIG_From_int(static_cast< int >(result));
50733 return resultobj;
50734 fail:
50735 return NULL;
50736 }
50737
50738
50739 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50740 PyObject *resultobj = 0;
50741 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50742 int result;
50743 void *argp1 = 0 ;
50744 int res1 = 0 ;
50745 PyObject *swig_obj[1] ;
50746
50747 if (!args) SWIG_fail;
50748 swig_obj[0] = args;
50749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50750 if (!SWIG_IsOK(res1)) {
50751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50752 }
50753 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50754 {
50755 PyThreadState* __tstate = wxPyBeginAllowThreads();
50756 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50757 wxPyEndAllowThreads(__tstate);
50758 if (PyErr_Occurred()) SWIG_fail;
50759 }
50760 resultobj = SWIG_From_int(static_cast< int >(result));
50761 return resultobj;
50762 fail:
50763 return NULL;
50764 }
50765
50766
50767 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50768 PyObject *resultobj = 0;
50769 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50770 int arg2 ;
50771 void *argp1 = 0 ;
50772 int res1 = 0 ;
50773 int val2 ;
50774 int ecode2 = 0 ;
50775 PyObject * obj0 = 0 ;
50776 PyObject * obj1 = 0 ;
50777 char * kwnames[] = {
50778 (char *) "self",(char *) "rowspan", NULL
50779 };
50780
50781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50783 if (!SWIG_IsOK(res1)) {
50784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50785 }
50786 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50787 ecode2 = SWIG_AsVal_int(obj1, &val2);
50788 if (!SWIG_IsOK(ecode2)) {
50789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50790 }
50791 arg2 = static_cast< int >(val2);
50792 {
50793 PyThreadState* __tstate = wxPyBeginAllowThreads();
50794 (arg1)->SetRowspan(arg2);
50795 wxPyEndAllowThreads(__tstate);
50796 if (PyErr_Occurred()) SWIG_fail;
50797 }
50798 resultobj = SWIG_Py_Void();
50799 return resultobj;
50800 fail:
50801 return NULL;
50802 }
50803
50804
50805 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50806 PyObject *resultobj = 0;
50807 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50808 int arg2 ;
50809 void *argp1 = 0 ;
50810 int res1 = 0 ;
50811 int val2 ;
50812 int ecode2 = 0 ;
50813 PyObject * obj0 = 0 ;
50814 PyObject * obj1 = 0 ;
50815 char * kwnames[] = {
50816 (char *) "self",(char *) "colspan", NULL
50817 };
50818
50819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50821 if (!SWIG_IsOK(res1)) {
50822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50823 }
50824 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50825 ecode2 = SWIG_AsVal_int(obj1, &val2);
50826 if (!SWIG_IsOK(ecode2)) {
50827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50828 }
50829 arg2 = static_cast< int >(val2);
50830 {
50831 PyThreadState* __tstate = wxPyBeginAllowThreads();
50832 (arg1)->SetColspan(arg2);
50833 wxPyEndAllowThreads(__tstate);
50834 if (PyErr_Occurred()) SWIG_fail;
50835 }
50836 resultobj = SWIG_Py_Void();
50837 return resultobj;
50838 fail:
50839 return NULL;
50840 }
50841
50842
50843 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50844 PyObject *resultobj = 0;
50845 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50846 PyObject *arg2 = (PyObject *) 0 ;
50847 bool result;
50848 void *argp1 = 0 ;
50849 int res1 = 0 ;
50850 PyObject * obj0 = 0 ;
50851 PyObject * obj1 = 0 ;
50852 char * kwnames[] = {
50853 (char *) "self",(char *) "other", NULL
50854 };
50855
50856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50858 if (!SWIG_IsOK(res1)) {
50859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50860 }
50861 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50862 arg2 = obj1;
50863 {
50864 result = (bool)wxGBSpan___eq__(arg1,arg2);
50865 if (PyErr_Occurred()) SWIG_fail;
50866 }
50867 {
50868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50869 }
50870 return resultobj;
50871 fail:
50872 return NULL;
50873 }
50874
50875
50876 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50877 PyObject *resultobj = 0;
50878 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50879 PyObject *arg2 = (PyObject *) 0 ;
50880 bool result;
50881 void *argp1 = 0 ;
50882 int res1 = 0 ;
50883 PyObject * obj0 = 0 ;
50884 PyObject * obj1 = 0 ;
50885 char * kwnames[] = {
50886 (char *) "self",(char *) "other", NULL
50887 };
50888
50889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50891 if (!SWIG_IsOK(res1)) {
50892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50893 }
50894 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50895 arg2 = obj1;
50896 {
50897 result = (bool)wxGBSpan___ne__(arg1,arg2);
50898 if (PyErr_Occurred()) SWIG_fail;
50899 }
50900 {
50901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50902 }
50903 return resultobj;
50904 fail:
50905 return NULL;
50906 }
50907
50908
50909 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50910 PyObject *resultobj = 0;
50911 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50912 int arg2 = (int) 1 ;
50913 int arg3 = (int) 1 ;
50914 void *argp1 = 0 ;
50915 int res1 = 0 ;
50916 int val2 ;
50917 int ecode2 = 0 ;
50918 int val3 ;
50919 int ecode3 = 0 ;
50920 PyObject * obj0 = 0 ;
50921 PyObject * obj1 = 0 ;
50922 PyObject * obj2 = 0 ;
50923 char * kwnames[] = {
50924 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50925 };
50926
50927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50929 if (!SWIG_IsOK(res1)) {
50930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50931 }
50932 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50933 if (obj1) {
50934 ecode2 = SWIG_AsVal_int(obj1, &val2);
50935 if (!SWIG_IsOK(ecode2)) {
50936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50937 }
50938 arg2 = static_cast< int >(val2);
50939 }
50940 if (obj2) {
50941 ecode3 = SWIG_AsVal_int(obj2, &val3);
50942 if (!SWIG_IsOK(ecode3)) {
50943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50944 }
50945 arg3 = static_cast< int >(val3);
50946 }
50947 {
50948 PyThreadState* __tstate = wxPyBeginAllowThreads();
50949 wxGBSpan_Set(arg1,arg2,arg3);
50950 wxPyEndAllowThreads(__tstate);
50951 if (PyErr_Occurred()) SWIG_fail;
50952 }
50953 resultobj = SWIG_Py_Void();
50954 return resultobj;
50955 fail:
50956 return NULL;
50957 }
50958
50959
50960 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50961 PyObject *resultobj = 0;
50962 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50963 PyObject *result = 0 ;
50964 void *argp1 = 0 ;
50965 int res1 = 0 ;
50966 PyObject *swig_obj[1] ;
50967
50968 if (!args) SWIG_fail;
50969 swig_obj[0] = args;
50970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50971 if (!SWIG_IsOK(res1)) {
50972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50973 }
50974 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50975 {
50976 PyThreadState* __tstate = wxPyBeginAllowThreads();
50977 result = (PyObject *)wxGBSpan_Get(arg1);
50978 wxPyEndAllowThreads(__tstate);
50979 if (PyErr_Occurred()) SWIG_fail;
50980 }
50981 resultobj = result;
50982 return resultobj;
50983 fail:
50984 return NULL;
50985 }
50986
50987
50988 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50989 PyObject *obj;
50990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50991 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50992 return SWIG_Py_Void();
50993 }
50994
50995 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50996 return SWIG_Python_InitShadowInstance(args);
50997 }
50998
50999 SWIGINTERN int DefaultSpan_set(PyObject *) {
51000 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51001 return 1;
51002 }
51003
51004
51005 SWIGINTERN PyObject *DefaultSpan_get(void) {
51006 PyObject *pyobj = 0;
51007
51008 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51009 return pyobj;
51010 }
51011
51012
51013 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51014 PyObject *resultobj = 0;
51015 wxGBSizerItem *result = 0 ;
51016
51017 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51018 {
51019 PyThreadState* __tstate = wxPyBeginAllowThreads();
51020 result = (wxGBSizerItem *)new wxGBSizerItem();
51021 wxPyEndAllowThreads(__tstate);
51022 if (PyErr_Occurred()) SWIG_fail;
51023 }
51024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51025 return resultobj;
51026 fail:
51027 return NULL;
51028 }
51029
51030
51031 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51032 PyObject *resultobj = 0;
51033 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51034 void *argp1 = 0 ;
51035 int res1 = 0 ;
51036 PyObject *swig_obj[1] ;
51037
51038 if (!args) SWIG_fail;
51039 swig_obj[0] = args;
51040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51041 if (!SWIG_IsOK(res1)) {
51042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51043 }
51044 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51045 {
51046 PyThreadState* __tstate = wxPyBeginAllowThreads();
51047 delete arg1;
51048
51049 wxPyEndAllowThreads(__tstate);
51050 if (PyErr_Occurred()) SWIG_fail;
51051 }
51052 resultobj = SWIG_Py_Void();
51053 return resultobj;
51054 fail:
51055 return NULL;
51056 }
51057
51058
51059 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51060 PyObject *resultobj = 0;
51061 wxWindow *arg1 = (wxWindow *) 0 ;
51062 wxGBPosition *arg2 = 0 ;
51063 wxGBSpan *arg3 = 0 ;
51064 int arg4 ;
51065 int arg5 ;
51066 PyObject *arg6 = (PyObject *) NULL ;
51067 wxGBSizerItem *result = 0 ;
51068 void *argp1 = 0 ;
51069 int res1 = 0 ;
51070 wxGBPosition temp2 ;
51071 wxGBSpan temp3 ;
51072 int val4 ;
51073 int ecode4 = 0 ;
51074 int val5 ;
51075 int ecode5 = 0 ;
51076 PyObject * obj0 = 0 ;
51077 PyObject * obj1 = 0 ;
51078 PyObject * obj2 = 0 ;
51079 PyObject * obj3 = 0 ;
51080 PyObject * obj4 = 0 ;
51081 PyObject * obj5 = 0 ;
51082 char * kwnames[] = {
51083 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51084 };
51085
51086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51088 if (!SWIG_IsOK(res1)) {
51089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51090 }
51091 arg1 = reinterpret_cast< wxWindow * >(argp1);
51092 {
51093 arg2 = &temp2;
51094 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51095 }
51096 {
51097 arg3 = &temp3;
51098 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51099 }
51100 ecode4 = SWIG_AsVal_int(obj3, &val4);
51101 if (!SWIG_IsOK(ecode4)) {
51102 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51103 }
51104 arg4 = static_cast< int >(val4);
51105 ecode5 = SWIG_AsVal_int(obj4, &val5);
51106 if (!SWIG_IsOK(ecode5)) {
51107 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51108 }
51109 arg5 = static_cast< int >(val5);
51110 if (obj5) {
51111 arg6 = obj5;
51112 }
51113 {
51114 PyThreadState* __tstate = wxPyBeginAllowThreads();
51115 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51116 wxPyEndAllowThreads(__tstate);
51117 if (PyErr_Occurred()) SWIG_fail;
51118 }
51119 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51120 return resultobj;
51121 fail:
51122 return NULL;
51123 }
51124
51125
51126 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51127 PyObject *resultobj = 0;
51128 wxSizer *arg1 = (wxSizer *) 0 ;
51129 wxGBPosition *arg2 = 0 ;
51130 wxGBSpan *arg3 = 0 ;
51131 int arg4 ;
51132 int arg5 ;
51133 PyObject *arg6 = (PyObject *) NULL ;
51134 wxGBSizerItem *result = 0 ;
51135 int res1 = 0 ;
51136 wxGBPosition temp2 ;
51137 wxGBSpan temp3 ;
51138 int val4 ;
51139 int ecode4 = 0 ;
51140 int val5 ;
51141 int ecode5 = 0 ;
51142 PyObject * obj0 = 0 ;
51143 PyObject * obj1 = 0 ;
51144 PyObject * obj2 = 0 ;
51145 PyObject * obj3 = 0 ;
51146 PyObject * obj4 = 0 ;
51147 PyObject * obj5 = 0 ;
51148 char * kwnames[] = {
51149 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51150 };
51151
51152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51153 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51154 if (!SWIG_IsOK(res1)) {
51155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51156 }
51157 {
51158 arg2 = &temp2;
51159 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51160 }
51161 {
51162 arg3 = &temp3;
51163 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51164 }
51165 ecode4 = SWIG_AsVal_int(obj3, &val4);
51166 if (!SWIG_IsOK(ecode4)) {
51167 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51168 }
51169 arg4 = static_cast< int >(val4);
51170 ecode5 = SWIG_AsVal_int(obj4, &val5);
51171 if (!SWIG_IsOK(ecode5)) {
51172 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51173 }
51174 arg5 = static_cast< int >(val5);
51175 if (obj5) {
51176 arg6 = obj5;
51177 }
51178 {
51179 PyThreadState* __tstate = wxPyBeginAllowThreads();
51180 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51181 wxPyEndAllowThreads(__tstate);
51182 if (PyErr_Occurred()) SWIG_fail;
51183 }
51184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51185 return resultobj;
51186 fail:
51187 return NULL;
51188 }
51189
51190
51191 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51192 PyObject *resultobj = 0;
51193 int arg1 ;
51194 int arg2 ;
51195 wxGBPosition *arg3 = 0 ;
51196 wxGBSpan *arg4 = 0 ;
51197 int arg5 ;
51198 int arg6 ;
51199 PyObject *arg7 = (PyObject *) NULL ;
51200 wxGBSizerItem *result = 0 ;
51201 int val1 ;
51202 int ecode1 = 0 ;
51203 int val2 ;
51204 int ecode2 = 0 ;
51205 wxGBPosition temp3 ;
51206 wxGBSpan temp4 ;
51207 int val5 ;
51208 int ecode5 = 0 ;
51209 int val6 ;
51210 int ecode6 = 0 ;
51211 PyObject * obj0 = 0 ;
51212 PyObject * obj1 = 0 ;
51213 PyObject * obj2 = 0 ;
51214 PyObject * obj3 = 0 ;
51215 PyObject * obj4 = 0 ;
51216 PyObject * obj5 = 0 ;
51217 PyObject * obj6 = 0 ;
51218 char * kwnames[] = {
51219 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51220 };
51221
51222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51223 ecode1 = SWIG_AsVal_int(obj0, &val1);
51224 if (!SWIG_IsOK(ecode1)) {
51225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51226 }
51227 arg1 = static_cast< int >(val1);
51228 ecode2 = SWIG_AsVal_int(obj1, &val2);
51229 if (!SWIG_IsOK(ecode2)) {
51230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51231 }
51232 arg2 = static_cast< int >(val2);
51233 {
51234 arg3 = &temp3;
51235 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51236 }
51237 {
51238 arg4 = &temp4;
51239 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51240 }
51241 ecode5 = SWIG_AsVal_int(obj4, &val5);
51242 if (!SWIG_IsOK(ecode5)) {
51243 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51244 }
51245 arg5 = static_cast< int >(val5);
51246 ecode6 = SWIG_AsVal_int(obj5, &val6);
51247 if (!SWIG_IsOK(ecode6)) {
51248 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51249 }
51250 arg6 = static_cast< int >(val6);
51251 if (obj6) {
51252 arg7 = obj6;
51253 }
51254 {
51255 PyThreadState* __tstate = wxPyBeginAllowThreads();
51256 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51257 wxPyEndAllowThreads(__tstate);
51258 if (PyErr_Occurred()) SWIG_fail;
51259 }
51260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51261 return resultobj;
51262 fail:
51263 return NULL;
51264 }
51265
51266
51267 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51268 PyObject *resultobj = 0;
51269 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51270 wxGBPosition result;
51271 void *argp1 = 0 ;
51272 int res1 = 0 ;
51273 PyObject *swig_obj[1] ;
51274
51275 if (!args) SWIG_fail;
51276 swig_obj[0] = args;
51277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51278 if (!SWIG_IsOK(res1)) {
51279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51280 }
51281 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51282 {
51283 PyThreadState* __tstate = wxPyBeginAllowThreads();
51284 result = ((wxGBSizerItem const *)arg1)->GetPos();
51285 wxPyEndAllowThreads(__tstate);
51286 if (PyErr_Occurred()) SWIG_fail;
51287 }
51288 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51289 return resultobj;
51290 fail:
51291 return NULL;
51292 }
51293
51294
51295 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51296 PyObject *resultobj = 0;
51297 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51298 wxGBSpan result;
51299 void *argp1 = 0 ;
51300 int res1 = 0 ;
51301 PyObject *swig_obj[1] ;
51302
51303 if (!args) SWIG_fail;
51304 swig_obj[0] = args;
51305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51306 if (!SWIG_IsOK(res1)) {
51307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51308 }
51309 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51310 {
51311 PyThreadState* __tstate = wxPyBeginAllowThreads();
51312 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51313 wxPyEndAllowThreads(__tstate);
51314 if (PyErr_Occurred()) SWIG_fail;
51315 }
51316 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51317 return resultobj;
51318 fail:
51319 return NULL;
51320 }
51321
51322
51323 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51324 PyObject *resultobj = 0;
51325 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51326 wxGBPosition *arg2 = 0 ;
51327 bool result;
51328 void *argp1 = 0 ;
51329 int res1 = 0 ;
51330 wxGBPosition temp2 ;
51331 PyObject * obj0 = 0 ;
51332 PyObject * obj1 = 0 ;
51333 char * kwnames[] = {
51334 (char *) "self",(char *) "pos", NULL
51335 };
51336
51337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51339 if (!SWIG_IsOK(res1)) {
51340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51341 }
51342 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51343 {
51344 arg2 = &temp2;
51345 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51346 }
51347 {
51348 PyThreadState* __tstate = wxPyBeginAllowThreads();
51349 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51350 wxPyEndAllowThreads(__tstate);
51351 if (PyErr_Occurred()) SWIG_fail;
51352 }
51353 {
51354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51355 }
51356 return resultobj;
51357 fail:
51358 return NULL;
51359 }
51360
51361
51362 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51363 PyObject *resultobj = 0;
51364 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51365 wxGBSpan *arg2 = 0 ;
51366 bool result;
51367 void *argp1 = 0 ;
51368 int res1 = 0 ;
51369 wxGBSpan temp2 ;
51370 PyObject * obj0 = 0 ;
51371 PyObject * obj1 = 0 ;
51372 char * kwnames[] = {
51373 (char *) "self",(char *) "span", NULL
51374 };
51375
51376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51378 if (!SWIG_IsOK(res1)) {
51379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51380 }
51381 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51382 {
51383 arg2 = &temp2;
51384 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51385 }
51386 {
51387 PyThreadState* __tstate = wxPyBeginAllowThreads();
51388 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51389 wxPyEndAllowThreads(__tstate);
51390 if (PyErr_Occurred()) SWIG_fail;
51391 }
51392 {
51393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51394 }
51395 return resultobj;
51396 fail:
51397 return NULL;
51398 }
51399
51400
51401 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51402 PyObject *resultobj = 0;
51403 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51404 wxGBSizerItem *arg2 = 0 ;
51405 bool result;
51406 void *argp1 = 0 ;
51407 int res1 = 0 ;
51408 void *argp2 = 0 ;
51409 int res2 = 0 ;
51410 PyObject * obj0 = 0 ;
51411 PyObject * obj1 = 0 ;
51412 char * kwnames[] = {
51413 (char *) "self",(char *) "other", NULL
51414 };
51415
51416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51418 if (!SWIG_IsOK(res1)) {
51419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51420 }
51421 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51423 if (!SWIG_IsOK(res2)) {
51424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51425 }
51426 if (!argp2) {
51427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51428 }
51429 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51430 {
51431 PyThreadState* __tstate = wxPyBeginAllowThreads();
51432 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51433 wxPyEndAllowThreads(__tstate);
51434 if (PyErr_Occurred()) SWIG_fail;
51435 }
51436 {
51437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51438 }
51439 return resultobj;
51440 fail:
51441 return NULL;
51442 }
51443
51444
51445 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51446 PyObject *resultobj = 0;
51447 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51448 wxGBPosition *arg2 = 0 ;
51449 wxGBSpan *arg3 = 0 ;
51450 bool result;
51451 void *argp1 = 0 ;
51452 int res1 = 0 ;
51453 wxGBPosition temp2 ;
51454 wxGBSpan temp3 ;
51455 PyObject * obj0 = 0 ;
51456 PyObject * obj1 = 0 ;
51457 PyObject * obj2 = 0 ;
51458 char * kwnames[] = {
51459 (char *) "self",(char *) "pos",(char *) "span", NULL
51460 };
51461
51462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51464 if (!SWIG_IsOK(res1)) {
51465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51466 }
51467 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51468 {
51469 arg2 = &temp2;
51470 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51471 }
51472 {
51473 arg3 = &temp3;
51474 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51475 }
51476 {
51477 PyThreadState* __tstate = wxPyBeginAllowThreads();
51478 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51479 wxPyEndAllowThreads(__tstate);
51480 if (PyErr_Occurred()) SWIG_fail;
51481 }
51482 {
51483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51484 }
51485 return resultobj;
51486 fail:
51487 return NULL;
51488 }
51489
51490
51491 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51492 PyObject *resultobj = 0;
51493 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51494 wxGBPosition result;
51495 void *argp1 = 0 ;
51496 int res1 = 0 ;
51497 PyObject *swig_obj[1] ;
51498
51499 if (!args) SWIG_fail;
51500 swig_obj[0] = args;
51501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51502 if (!SWIG_IsOK(res1)) {
51503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51504 }
51505 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51506 {
51507 PyThreadState* __tstate = wxPyBeginAllowThreads();
51508 result = wxGBSizerItem_GetEndPos(arg1);
51509 wxPyEndAllowThreads(__tstate);
51510 if (PyErr_Occurred()) SWIG_fail;
51511 }
51512 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51513 return resultobj;
51514 fail:
51515 return NULL;
51516 }
51517
51518
51519 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51520 PyObject *resultobj = 0;
51521 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51522 wxGridBagSizer *result = 0 ;
51523 void *argp1 = 0 ;
51524 int res1 = 0 ;
51525 PyObject *swig_obj[1] ;
51526
51527 if (!args) SWIG_fail;
51528 swig_obj[0] = args;
51529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51532 }
51533 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51534 {
51535 PyThreadState* __tstate = wxPyBeginAllowThreads();
51536 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51537 wxPyEndAllowThreads(__tstate);
51538 if (PyErr_Occurred()) SWIG_fail;
51539 }
51540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51541 return resultobj;
51542 fail:
51543 return NULL;
51544 }
51545
51546
51547 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51548 PyObject *resultobj = 0;
51549 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51550 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
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 *) "sizer", NULL
51559 };
51560
51561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",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_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51565 }
51566 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51567 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51568 if (!SWIG_IsOK(res2)) {
51569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51570 }
51571 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51572 {
51573 PyThreadState* __tstate = wxPyBeginAllowThreads();
51574 (arg1)->SetGBSizer(arg2);
51575 wxPyEndAllowThreads(__tstate);
51576 if (PyErr_Occurred()) SWIG_fail;
51577 }
51578 resultobj = SWIG_Py_Void();
51579 return resultobj;
51580 fail:
51581 return NULL;
51582 }
51583
51584
51585 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51586 PyObject *obj;
51587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51588 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51589 return SWIG_Py_Void();
51590 }
51591
51592 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51593 return SWIG_Python_InitShadowInstance(args);
51594 }
51595
51596 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51597 PyObject *resultobj = 0;
51598 int arg1 = (int) 0 ;
51599 int arg2 = (int) 0 ;
51600 wxGridBagSizer *result = 0 ;
51601 int val1 ;
51602 int ecode1 = 0 ;
51603 int val2 ;
51604 int ecode2 = 0 ;
51605 PyObject * obj0 = 0 ;
51606 PyObject * obj1 = 0 ;
51607 char * kwnames[] = {
51608 (char *) "vgap",(char *) "hgap", NULL
51609 };
51610
51611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51612 if (obj0) {
51613 ecode1 = SWIG_AsVal_int(obj0, &val1);
51614 if (!SWIG_IsOK(ecode1)) {
51615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51616 }
51617 arg1 = static_cast< int >(val1);
51618 }
51619 if (obj1) {
51620 ecode2 = SWIG_AsVal_int(obj1, &val2);
51621 if (!SWIG_IsOK(ecode2)) {
51622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51623 }
51624 arg2 = static_cast< int >(val2);
51625 }
51626 {
51627 PyThreadState* __tstate = wxPyBeginAllowThreads();
51628 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51629 wxPyEndAllowThreads(__tstate);
51630 if (PyErr_Occurred()) SWIG_fail;
51631 }
51632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51633 return resultobj;
51634 fail:
51635 return NULL;
51636 }
51637
51638
51639 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51640 PyObject *resultobj = 0;
51641 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51642 PyObject *arg2 = (PyObject *) 0 ;
51643 wxGBPosition *arg3 = 0 ;
51644 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51645 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51646 int arg5 = (int) 0 ;
51647 int arg6 = (int) 0 ;
51648 PyObject *arg7 = (PyObject *) NULL ;
51649 wxGBSizerItem *result = 0 ;
51650 void *argp1 = 0 ;
51651 int res1 = 0 ;
51652 wxGBPosition temp3 ;
51653 wxGBSpan temp4 ;
51654 int val5 ;
51655 int ecode5 = 0 ;
51656 int val6 ;
51657 int ecode6 = 0 ;
51658 PyObject * obj0 = 0 ;
51659 PyObject * obj1 = 0 ;
51660 PyObject * obj2 = 0 ;
51661 PyObject * obj3 = 0 ;
51662 PyObject * obj4 = 0 ;
51663 PyObject * obj5 = 0 ;
51664 PyObject * obj6 = 0 ;
51665 char * kwnames[] = {
51666 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51667 };
51668
51669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51671 if (!SWIG_IsOK(res1)) {
51672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51673 }
51674 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51675 arg2 = obj1;
51676 {
51677 arg3 = &temp3;
51678 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51679 }
51680 if (obj3) {
51681 {
51682 arg4 = &temp4;
51683 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51684 }
51685 }
51686 if (obj4) {
51687 ecode5 = SWIG_AsVal_int(obj4, &val5);
51688 if (!SWIG_IsOK(ecode5)) {
51689 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51690 }
51691 arg5 = static_cast< int >(val5);
51692 }
51693 if (obj5) {
51694 ecode6 = SWIG_AsVal_int(obj5, &val6);
51695 if (!SWIG_IsOK(ecode6)) {
51696 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51697 }
51698 arg6 = static_cast< int >(val6);
51699 }
51700 if (obj6) {
51701 arg7 = obj6;
51702 }
51703 {
51704 PyThreadState* __tstate = wxPyBeginAllowThreads();
51705 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51706 wxPyEndAllowThreads(__tstate);
51707 if (PyErr_Occurred()) SWIG_fail;
51708 }
51709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51710 return resultobj;
51711 fail:
51712 return NULL;
51713 }
51714
51715
51716 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51717 PyObject *resultobj = 0;
51718 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51719 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51720 wxGBSizerItem *result = 0 ;
51721 void *argp1 = 0 ;
51722 int res1 = 0 ;
51723 int res2 = 0 ;
51724 PyObject * obj0 = 0 ;
51725 PyObject * obj1 = 0 ;
51726 char * kwnames[] = {
51727 (char *) "self",(char *) "item", NULL
51728 };
51729
51730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51732 if (!SWIG_IsOK(res1)) {
51733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51734 }
51735 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51736 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51737 if (!SWIG_IsOK(res2)) {
51738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51739 }
51740 {
51741 PyThreadState* __tstate = wxPyBeginAllowThreads();
51742 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51743 wxPyEndAllowThreads(__tstate);
51744 if (PyErr_Occurred()) SWIG_fail;
51745 }
51746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51747 return resultobj;
51748 fail:
51749 return NULL;
51750 }
51751
51752
51753 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51754 PyObject *resultobj = 0;
51755 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51756 int arg2 ;
51757 int arg3 ;
51758 wxSize result;
51759 void *argp1 = 0 ;
51760 int res1 = 0 ;
51761 int val2 ;
51762 int ecode2 = 0 ;
51763 int val3 ;
51764 int ecode3 = 0 ;
51765 PyObject * obj0 = 0 ;
51766 PyObject * obj1 = 0 ;
51767 PyObject * obj2 = 0 ;
51768 char * kwnames[] = {
51769 (char *) "self",(char *) "row",(char *) "col", NULL
51770 };
51771
51772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51774 if (!SWIG_IsOK(res1)) {
51775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51776 }
51777 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51778 ecode2 = SWIG_AsVal_int(obj1, &val2);
51779 if (!SWIG_IsOK(ecode2)) {
51780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51781 }
51782 arg2 = static_cast< int >(val2);
51783 ecode3 = SWIG_AsVal_int(obj2, &val3);
51784 if (!SWIG_IsOK(ecode3)) {
51785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51786 }
51787 arg3 = static_cast< int >(val3);
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51802 PyObject *resultobj = 0;
51803 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51804 wxSize result;
51805 void *argp1 = 0 ;
51806 int res1 = 0 ;
51807 PyObject *swig_obj[1] ;
51808
51809 if (!args) SWIG_fail;
51810 swig_obj[0] = args;
51811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51814 }
51815 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51816 {
51817 PyThreadState* __tstate = wxPyBeginAllowThreads();
51818 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51819 wxPyEndAllowThreads(__tstate);
51820 if (PyErr_Occurred()) SWIG_fail;
51821 }
51822 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51823 return resultobj;
51824 fail:
51825 return NULL;
51826 }
51827
51828
51829 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51830 PyObject *resultobj = 0;
51831 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51832 wxSize *arg2 = 0 ;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 wxSize temp2 ;
51836 PyObject * obj0 = 0 ;
51837 PyObject * obj1 = 0 ;
51838 char * kwnames[] = {
51839 (char *) "self",(char *) "sz", NULL
51840 };
51841
51842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51844 if (!SWIG_IsOK(res1)) {
51845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51846 }
51847 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51848 {
51849 arg2 = &temp2;
51850 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51851 }
51852 {
51853 PyThreadState* __tstate = wxPyBeginAllowThreads();
51854 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51855 wxPyEndAllowThreads(__tstate);
51856 if (PyErr_Occurred()) SWIG_fail;
51857 }
51858 resultobj = SWIG_Py_Void();
51859 return resultobj;
51860 fail:
51861 return NULL;
51862 }
51863
51864
51865 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51866 PyObject *resultobj = 0;
51867 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51868 wxWindow *arg2 = (wxWindow *) 0 ;
51869 wxGBPosition result;
51870 void *argp1 = 0 ;
51871 int res1 = 0 ;
51872 void *argp2 = 0 ;
51873 int res2 = 0 ;
51874
51875 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51877 if (!SWIG_IsOK(res1)) {
51878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51879 }
51880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51881 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51882 if (!SWIG_IsOK(res2)) {
51883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51884 }
51885 arg2 = reinterpret_cast< wxWindow * >(argp2);
51886 {
51887 PyThreadState* __tstate = wxPyBeginAllowThreads();
51888 result = (arg1)->GetItemPosition(arg2);
51889 wxPyEndAllowThreads(__tstate);
51890 if (PyErr_Occurred()) SWIG_fail;
51891 }
51892 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51893 return resultobj;
51894 fail:
51895 return NULL;
51896 }
51897
51898
51899 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51900 PyObject *resultobj = 0;
51901 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51902 wxSizer *arg2 = (wxSizer *) 0 ;
51903 wxGBPosition result;
51904 void *argp1 = 0 ;
51905 int res1 = 0 ;
51906 void *argp2 = 0 ;
51907 int res2 = 0 ;
51908
51909 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51911 if (!SWIG_IsOK(res1)) {
51912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51913 }
51914 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51915 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51916 if (!SWIG_IsOK(res2)) {
51917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51918 }
51919 arg2 = reinterpret_cast< wxSizer * >(argp2);
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 result = (arg1)->GetItemPosition(arg2);
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51927 return resultobj;
51928 fail:
51929 return NULL;
51930 }
51931
51932
51933 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51934 PyObject *resultobj = 0;
51935 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51936 size_t arg2 ;
51937 wxGBPosition result;
51938 void *argp1 = 0 ;
51939 int res1 = 0 ;
51940 size_t val2 ;
51941 int ecode2 = 0 ;
51942
51943 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51945 if (!SWIG_IsOK(res1)) {
51946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51947 }
51948 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51949 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51950 if (!SWIG_IsOK(ecode2)) {
51951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51952 }
51953 arg2 = static_cast< size_t >(val2);
51954 {
51955 PyThreadState* __tstate = wxPyBeginAllowThreads();
51956 result = (arg1)->GetItemPosition(arg2);
51957 wxPyEndAllowThreads(__tstate);
51958 if (PyErr_Occurred()) SWIG_fail;
51959 }
51960 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51961 return resultobj;
51962 fail:
51963 return NULL;
51964 }
51965
51966
51967 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51968 int argc;
51969 PyObject *argv[3];
51970
51971 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51972 --argc;
51973 if (argc == 2) {
51974 int _v = 0;
51975 {
51976 void *vptr = 0;
51977 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51978 _v = SWIG_CheckState(res);
51979 }
51980 if (!_v) goto check_1;
51981 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51982 }
51983 check_1:
51984
51985 if (argc == 2) {
51986 int _v = 0;
51987 {
51988 void *vptr = 0;
51989 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51990 _v = SWIG_CheckState(res);
51991 }
51992 if (!_v) goto check_2;
51993 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51994 }
51995 check_2:
51996
51997 if (argc == 2) {
51998 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51999 }
52000
52001 fail:
52002 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52003 return NULL;
52004 }
52005
52006
52007 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52008 PyObject *resultobj = 0;
52009 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52010 wxWindow *arg2 = (wxWindow *) 0 ;
52011 wxGBPosition *arg3 = 0 ;
52012 bool result;
52013 void *argp1 = 0 ;
52014 int res1 = 0 ;
52015 void *argp2 = 0 ;
52016 int res2 = 0 ;
52017 wxGBPosition temp3 ;
52018
52019 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52021 if (!SWIG_IsOK(res1)) {
52022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52023 }
52024 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52025 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52026 if (!SWIG_IsOK(res2)) {
52027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52028 }
52029 arg2 = reinterpret_cast< wxWindow * >(argp2);
52030 {
52031 arg3 = &temp3;
52032 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52033 }
52034 {
52035 PyThreadState* __tstate = wxPyBeginAllowThreads();
52036 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52037 wxPyEndAllowThreads(__tstate);
52038 if (PyErr_Occurred()) SWIG_fail;
52039 }
52040 {
52041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52042 }
52043 return resultobj;
52044 fail:
52045 return NULL;
52046 }
52047
52048
52049 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52050 PyObject *resultobj = 0;
52051 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52052 wxSizer *arg2 = (wxSizer *) 0 ;
52053 wxGBPosition *arg3 = 0 ;
52054 bool result;
52055 void *argp1 = 0 ;
52056 int res1 = 0 ;
52057 void *argp2 = 0 ;
52058 int res2 = 0 ;
52059 wxGBPosition temp3 ;
52060
52061 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52063 if (!SWIG_IsOK(res1)) {
52064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52065 }
52066 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52067 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52068 if (!SWIG_IsOK(res2)) {
52069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52070 }
52071 arg2 = reinterpret_cast< wxSizer * >(argp2);
52072 {
52073 arg3 = &temp3;
52074 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52075 }
52076 {
52077 PyThreadState* __tstate = wxPyBeginAllowThreads();
52078 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52079 wxPyEndAllowThreads(__tstate);
52080 if (PyErr_Occurred()) SWIG_fail;
52081 }
52082 {
52083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52084 }
52085 return resultobj;
52086 fail:
52087 return NULL;
52088 }
52089
52090
52091 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52092 PyObject *resultobj = 0;
52093 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52094 size_t arg2 ;
52095 wxGBPosition *arg3 = 0 ;
52096 bool result;
52097 void *argp1 = 0 ;
52098 int res1 = 0 ;
52099 size_t val2 ;
52100 int ecode2 = 0 ;
52101 wxGBPosition temp3 ;
52102
52103 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52107 }
52108 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52109 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52110 if (!SWIG_IsOK(ecode2)) {
52111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52112 }
52113 arg2 = static_cast< size_t >(val2);
52114 {
52115 arg3 = &temp3;
52116 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52117 }
52118 {
52119 PyThreadState* __tstate = wxPyBeginAllowThreads();
52120 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52121 wxPyEndAllowThreads(__tstate);
52122 if (PyErr_Occurred()) SWIG_fail;
52123 }
52124 {
52125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52126 }
52127 return resultobj;
52128 fail:
52129 return NULL;
52130 }
52131
52132
52133 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52134 int argc;
52135 PyObject *argv[4];
52136
52137 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52138 --argc;
52139 if (argc == 3) {
52140 int _v = 0;
52141 {
52142 void *vptr = 0;
52143 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52144 _v = SWIG_CheckState(res);
52145 }
52146 if (!_v) goto check_1;
52147 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52148 }
52149 check_1:
52150
52151 if (argc == 3) {
52152 int _v = 0;
52153 {
52154 void *vptr = 0;
52155 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52156 _v = SWIG_CheckState(res);
52157 }
52158 if (!_v) goto check_2;
52159 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52160 }
52161 check_2:
52162
52163 if (argc == 3) {
52164 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52165 }
52166
52167 fail:
52168 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52174 PyObject *resultobj = 0;
52175 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52176 wxWindow *arg2 = (wxWindow *) 0 ;
52177 wxGBSpan result;
52178 void *argp1 = 0 ;
52179 int res1 = 0 ;
52180 void *argp2 = 0 ;
52181 int res2 = 0 ;
52182
52183 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52185 if (!SWIG_IsOK(res1)) {
52186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52187 }
52188 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52189 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52190 if (!SWIG_IsOK(res2)) {
52191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52192 }
52193 arg2 = reinterpret_cast< wxWindow * >(argp2);
52194 {
52195 PyThreadState* __tstate = wxPyBeginAllowThreads();
52196 result = (arg1)->GetItemSpan(arg2);
52197 wxPyEndAllowThreads(__tstate);
52198 if (PyErr_Occurred()) SWIG_fail;
52199 }
52200 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52201 return resultobj;
52202 fail:
52203 return NULL;
52204 }
52205
52206
52207 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52208 PyObject *resultobj = 0;
52209 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52210 wxSizer *arg2 = (wxSizer *) 0 ;
52211 wxGBSpan result;
52212 void *argp1 = 0 ;
52213 int res1 = 0 ;
52214 void *argp2 = 0 ;
52215 int res2 = 0 ;
52216
52217 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52219 if (!SWIG_IsOK(res1)) {
52220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52221 }
52222 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52223 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52224 if (!SWIG_IsOK(res2)) {
52225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52226 }
52227 arg2 = reinterpret_cast< wxSizer * >(argp2);
52228 {
52229 PyThreadState* __tstate = wxPyBeginAllowThreads();
52230 result = (arg1)->GetItemSpan(arg2);
52231 wxPyEndAllowThreads(__tstate);
52232 if (PyErr_Occurred()) SWIG_fail;
52233 }
52234 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52235 return resultobj;
52236 fail:
52237 return NULL;
52238 }
52239
52240
52241 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52242 PyObject *resultobj = 0;
52243 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52244 size_t arg2 ;
52245 wxGBSpan result;
52246 void *argp1 = 0 ;
52247 int res1 = 0 ;
52248 size_t val2 ;
52249 int ecode2 = 0 ;
52250
52251 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52255 }
52256 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52257 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52258 if (!SWIG_IsOK(ecode2)) {
52259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52260 }
52261 arg2 = static_cast< size_t >(val2);
52262 {
52263 PyThreadState* __tstate = wxPyBeginAllowThreads();
52264 result = (arg1)->GetItemSpan(arg2);
52265 wxPyEndAllowThreads(__tstate);
52266 if (PyErr_Occurred()) SWIG_fail;
52267 }
52268 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52269 return resultobj;
52270 fail:
52271 return NULL;
52272 }
52273
52274
52275 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52276 int argc;
52277 PyObject *argv[3];
52278
52279 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52280 --argc;
52281 if (argc == 2) {
52282 int _v = 0;
52283 {
52284 void *vptr = 0;
52285 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52286 _v = SWIG_CheckState(res);
52287 }
52288 if (!_v) goto check_1;
52289 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52290 }
52291 check_1:
52292
52293 if (argc == 2) {
52294 int _v = 0;
52295 {
52296 void *vptr = 0;
52297 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52298 _v = SWIG_CheckState(res);
52299 }
52300 if (!_v) goto check_2;
52301 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52302 }
52303 check_2:
52304
52305 if (argc == 2) {
52306 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52307 }
52308
52309 fail:
52310 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52311 return NULL;
52312 }
52313
52314
52315 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52316 PyObject *resultobj = 0;
52317 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52318 wxWindow *arg2 = (wxWindow *) 0 ;
52319 wxGBSpan *arg3 = 0 ;
52320 bool result;
52321 void *argp1 = 0 ;
52322 int res1 = 0 ;
52323 void *argp2 = 0 ;
52324 int res2 = 0 ;
52325 wxGBSpan temp3 ;
52326
52327 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52329 if (!SWIG_IsOK(res1)) {
52330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52331 }
52332 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52333 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52334 if (!SWIG_IsOK(res2)) {
52335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52336 }
52337 arg2 = reinterpret_cast< wxWindow * >(argp2);
52338 {
52339 arg3 = &temp3;
52340 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52341 }
52342 {
52343 PyThreadState* __tstate = wxPyBeginAllowThreads();
52344 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52345 wxPyEndAllowThreads(__tstate);
52346 if (PyErr_Occurred()) SWIG_fail;
52347 }
52348 {
52349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52350 }
52351 return resultobj;
52352 fail:
52353 return NULL;
52354 }
52355
52356
52357 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52358 PyObject *resultobj = 0;
52359 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52360 wxSizer *arg2 = (wxSizer *) 0 ;
52361 wxGBSpan *arg3 = 0 ;
52362 bool result;
52363 void *argp1 = 0 ;
52364 int res1 = 0 ;
52365 void *argp2 = 0 ;
52366 int res2 = 0 ;
52367 wxGBSpan temp3 ;
52368
52369 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52371 if (!SWIG_IsOK(res1)) {
52372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52373 }
52374 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52375 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52376 if (!SWIG_IsOK(res2)) {
52377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52378 }
52379 arg2 = reinterpret_cast< wxSizer * >(argp2);
52380 {
52381 arg3 = &temp3;
52382 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52383 }
52384 {
52385 PyThreadState* __tstate = wxPyBeginAllowThreads();
52386 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52387 wxPyEndAllowThreads(__tstate);
52388 if (PyErr_Occurred()) SWIG_fail;
52389 }
52390 {
52391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52392 }
52393 return resultobj;
52394 fail:
52395 return NULL;
52396 }
52397
52398
52399 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52400 PyObject *resultobj = 0;
52401 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52402 size_t arg2 ;
52403 wxGBSpan *arg3 = 0 ;
52404 bool result;
52405 void *argp1 = 0 ;
52406 int res1 = 0 ;
52407 size_t val2 ;
52408 int ecode2 = 0 ;
52409 wxGBSpan temp3 ;
52410
52411 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52413 if (!SWIG_IsOK(res1)) {
52414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52415 }
52416 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52417 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52418 if (!SWIG_IsOK(ecode2)) {
52419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52420 }
52421 arg2 = static_cast< size_t >(val2);
52422 {
52423 arg3 = &temp3;
52424 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52425 }
52426 {
52427 PyThreadState* __tstate = wxPyBeginAllowThreads();
52428 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52429 wxPyEndAllowThreads(__tstate);
52430 if (PyErr_Occurred()) SWIG_fail;
52431 }
52432 {
52433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52434 }
52435 return resultobj;
52436 fail:
52437 return NULL;
52438 }
52439
52440
52441 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52442 int argc;
52443 PyObject *argv[4];
52444
52445 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52446 --argc;
52447 if (argc == 3) {
52448 int _v = 0;
52449 {
52450 void *vptr = 0;
52451 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52452 _v = SWIG_CheckState(res);
52453 }
52454 if (!_v) goto check_1;
52455 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52456 }
52457 check_1:
52458
52459 if (argc == 3) {
52460 int _v = 0;
52461 {
52462 void *vptr = 0;
52463 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52464 _v = SWIG_CheckState(res);
52465 }
52466 if (!_v) goto check_2;
52467 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52468 }
52469 check_2:
52470
52471 if (argc == 3) {
52472 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52473 }
52474
52475 fail:
52476 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52477 return NULL;
52478 }
52479
52480
52481 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52482 PyObject *resultobj = 0;
52483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52484 wxWindow *arg2 = (wxWindow *) 0 ;
52485 wxGBSizerItem *result = 0 ;
52486 void *argp1 = 0 ;
52487 int res1 = 0 ;
52488 void *argp2 = 0 ;
52489 int res2 = 0 ;
52490
52491 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52495 }
52496 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52497 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52498 if (!SWIG_IsOK(res2)) {
52499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52500 }
52501 arg2 = reinterpret_cast< wxWindow * >(argp2);
52502 {
52503 PyThreadState* __tstate = wxPyBeginAllowThreads();
52504 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52505 wxPyEndAllowThreads(__tstate);
52506 if (PyErr_Occurred()) SWIG_fail;
52507 }
52508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52509 return resultobj;
52510 fail:
52511 return NULL;
52512 }
52513
52514
52515 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52516 PyObject *resultobj = 0;
52517 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52518 wxSizer *arg2 = (wxSizer *) 0 ;
52519 wxGBSizerItem *result = 0 ;
52520 void *argp1 = 0 ;
52521 int res1 = 0 ;
52522 void *argp2 = 0 ;
52523 int res2 = 0 ;
52524
52525 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52527 if (!SWIG_IsOK(res1)) {
52528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52529 }
52530 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52531 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52532 if (!SWIG_IsOK(res2)) {
52533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52534 }
52535 arg2 = reinterpret_cast< wxSizer * >(argp2);
52536 {
52537 PyThreadState* __tstate = wxPyBeginAllowThreads();
52538 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52539 wxPyEndAllowThreads(__tstate);
52540 if (PyErr_Occurred()) SWIG_fail;
52541 }
52542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52543 return resultobj;
52544 fail:
52545 return NULL;
52546 }
52547
52548
52549 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52550 int argc;
52551 PyObject *argv[3];
52552
52553 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52554 --argc;
52555 if (argc == 2) {
52556 int _v = 0;
52557 {
52558 void *vptr = 0;
52559 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52560 _v = SWIG_CheckState(res);
52561 }
52562 if (!_v) goto check_1;
52563 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52564 }
52565 check_1:
52566
52567 if (argc == 2) {
52568 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52569 }
52570
52571 fail:
52572 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52573 return NULL;
52574 }
52575
52576
52577 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52578 PyObject *resultobj = 0;
52579 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52580 wxGBPosition *arg2 = 0 ;
52581 wxGBSizerItem *result = 0 ;
52582 void *argp1 = 0 ;
52583 int res1 = 0 ;
52584 wxGBPosition temp2 ;
52585 PyObject * obj0 = 0 ;
52586 PyObject * obj1 = 0 ;
52587 char * kwnames[] = {
52588 (char *) "self",(char *) "pos", NULL
52589 };
52590
52591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52593 if (!SWIG_IsOK(res1)) {
52594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52595 }
52596 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52597 {
52598 arg2 = &temp2;
52599 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52600 }
52601 {
52602 PyThreadState* __tstate = wxPyBeginAllowThreads();
52603 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52604 wxPyEndAllowThreads(__tstate);
52605 if (PyErr_Occurred()) SWIG_fail;
52606 }
52607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52608 return resultobj;
52609 fail:
52610 return NULL;
52611 }
52612
52613
52614 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52615 PyObject *resultobj = 0;
52616 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52617 wxPoint *arg2 = 0 ;
52618 wxGBSizerItem *result = 0 ;
52619 void *argp1 = 0 ;
52620 int res1 = 0 ;
52621 wxPoint temp2 ;
52622 PyObject * obj0 = 0 ;
52623 PyObject * obj1 = 0 ;
52624 char * kwnames[] = {
52625 (char *) "self",(char *) "pt", NULL
52626 };
52627
52628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52630 if (!SWIG_IsOK(res1)) {
52631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52632 }
52633 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52634 {
52635 arg2 = &temp2;
52636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52637 }
52638 {
52639 PyThreadState* __tstate = wxPyBeginAllowThreads();
52640 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52641 wxPyEndAllowThreads(__tstate);
52642 if (PyErr_Occurred()) SWIG_fail;
52643 }
52644 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52645 return resultobj;
52646 fail:
52647 return NULL;
52648 }
52649
52650
52651 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52652 PyObject *resultobj = 0;
52653 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52654 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52655 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52656 bool result;
52657 void *argp1 = 0 ;
52658 int res1 = 0 ;
52659 void *argp2 = 0 ;
52660 int res2 = 0 ;
52661 void *argp3 = 0 ;
52662 int res3 = 0 ;
52663 PyObject * obj0 = 0 ;
52664 PyObject * obj1 = 0 ;
52665 PyObject * obj2 = 0 ;
52666 char * kwnames[] = {
52667 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52668 };
52669
52670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52674 }
52675 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52677 if (!SWIG_IsOK(res2)) {
52678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52679 }
52680 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52681 if (obj2) {
52682 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52683 if (!SWIG_IsOK(res3)) {
52684 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52685 }
52686 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52687 }
52688 {
52689 PyThreadState* __tstate = wxPyBeginAllowThreads();
52690 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52691 wxPyEndAllowThreads(__tstate);
52692 if (PyErr_Occurred()) SWIG_fail;
52693 }
52694 {
52695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52696 }
52697 return resultobj;
52698 fail:
52699 return NULL;
52700 }
52701
52702
52703 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52704 PyObject *resultobj = 0;
52705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52706 wxGBPosition *arg2 = 0 ;
52707 wxGBSpan *arg3 = 0 ;
52708 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52709 bool result;
52710 void *argp1 = 0 ;
52711 int res1 = 0 ;
52712 wxGBPosition temp2 ;
52713 wxGBSpan temp3 ;
52714 void *argp4 = 0 ;
52715 int res4 = 0 ;
52716 PyObject * obj0 = 0 ;
52717 PyObject * obj1 = 0 ;
52718 PyObject * obj2 = 0 ;
52719 PyObject * obj3 = 0 ;
52720 char * kwnames[] = {
52721 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52722 };
52723
52724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52726 if (!SWIG_IsOK(res1)) {
52727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52728 }
52729 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52730 {
52731 arg2 = &temp2;
52732 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52733 }
52734 {
52735 arg3 = &temp3;
52736 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52737 }
52738 if (obj3) {
52739 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52740 if (!SWIG_IsOK(res4)) {
52741 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52742 }
52743 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52744 }
52745 {
52746 PyThreadState* __tstate = wxPyBeginAllowThreads();
52747 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52748 wxPyEndAllowThreads(__tstate);
52749 if (PyErr_Occurred()) SWIG_fail;
52750 }
52751 {
52752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52753 }
52754 return resultobj;
52755 fail:
52756 return NULL;
52757 }
52758
52759
52760 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52761 PyObject *obj;
52762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52763 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52764 return SWIG_Py_Void();
52765 }
52766
52767 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52768 return SWIG_Python_InitShadowInstance(args);
52769 }
52770
52771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52772 PyObject *resultobj = 0;
52773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52774 wxRelationship arg2 ;
52775 wxWindow *arg3 = (wxWindow *) 0 ;
52776 wxEdge arg4 ;
52777 int arg5 = (int) 0 ;
52778 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52779 void *argp1 = 0 ;
52780 int res1 = 0 ;
52781 int val2 ;
52782 int ecode2 = 0 ;
52783 void *argp3 = 0 ;
52784 int res3 = 0 ;
52785 int val4 ;
52786 int ecode4 = 0 ;
52787 int val5 ;
52788 int ecode5 = 0 ;
52789 int val6 ;
52790 int ecode6 = 0 ;
52791 PyObject * obj0 = 0 ;
52792 PyObject * obj1 = 0 ;
52793 PyObject * obj2 = 0 ;
52794 PyObject * obj3 = 0 ;
52795 PyObject * obj4 = 0 ;
52796 PyObject * obj5 = 0 ;
52797 char * kwnames[] = {
52798 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52799 };
52800
52801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52803 if (!SWIG_IsOK(res1)) {
52804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52805 }
52806 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52807 ecode2 = SWIG_AsVal_int(obj1, &val2);
52808 if (!SWIG_IsOK(ecode2)) {
52809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52810 }
52811 arg2 = static_cast< wxRelationship >(val2);
52812 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52813 if (!SWIG_IsOK(res3)) {
52814 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52815 }
52816 arg3 = reinterpret_cast< wxWindow * >(argp3);
52817 ecode4 = SWIG_AsVal_int(obj3, &val4);
52818 if (!SWIG_IsOK(ecode4)) {
52819 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52820 }
52821 arg4 = static_cast< wxEdge >(val4);
52822 if (obj4) {
52823 ecode5 = SWIG_AsVal_int(obj4, &val5);
52824 if (!SWIG_IsOK(ecode5)) {
52825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52826 }
52827 arg5 = static_cast< int >(val5);
52828 }
52829 if (obj5) {
52830 ecode6 = SWIG_AsVal_int(obj5, &val6);
52831 if (!SWIG_IsOK(ecode6)) {
52832 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52833 }
52834 arg6 = static_cast< int >(val6);
52835 }
52836 {
52837 PyThreadState* __tstate = wxPyBeginAllowThreads();
52838 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52839 wxPyEndAllowThreads(__tstate);
52840 if (PyErr_Occurred()) SWIG_fail;
52841 }
52842 resultobj = SWIG_Py_Void();
52843 return resultobj;
52844 fail:
52845 return NULL;
52846 }
52847
52848
52849 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52850 PyObject *resultobj = 0;
52851 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52852 wxWindow *arg2 = (wxWindow *) 0 ;
52853 int arg3 = (int) 0 ;
52854 void *argp1 = 0 ;
52855 int res1 = 0 ;
52856 void *argp2 = 0 ;
52857 int res2 = 0 ;
52858 int val3 ;
52859 int ecode3 = 0 ;
52860 PyObject * obj0 = 0 ;
52861 PyObject * obj1 = 0 ;
52862 PyObject * obj2 = 0 ;
52863 char * kwnames[] = {
52864 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52865 };
52866
52867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52869 if (!SWIG_IsOK(res1)) {
52870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52871 }
52872 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52874 if (!SWIG_IsOK(res2)) {
52875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52876 }
52877 arg2 = reinterpret_cast< wxWindow * >(argp2);
52878 if (obj2) {
52879 ecode3 = SWIG_AsVal_int(obj2, &val3);
52880 if (!SWIG_IsOK(ecode3)) {
52881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52882 }
52883 arg3 = static_cast< int >(val3);
52884 }
52885 {
52886 PyThreadState* __tstate = wxPyBeginAllowThreads();
52887 (arg1)->LeftOf(arg2,arg3);
52888 wxPyEndAllowThreads(__tstate);
52889 if (PyErr_Occurred()) SWIG_fail;
52890 }
52891 resultobj = SWIG_Py_Void();
52892 return resultobj;
52893 fail:
52894 return NULL;
52895 }
52896
52897
52898 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52899 PyObject *resultobj = 0;
52900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52901 wxWindow *arg2 = (wxWindow *) 0 ;
52902 int arg3 = (int) 0 ;
52903 void *argp1 = 0 ;
52904 int res1 = 0 ;
52905 void *argp2 = 0 ;
52906 int res2 = 0 ;
52907 int val3 ;
52908 int ecode3 = 0 ;
52909 PyObject * obj0 = 0 ;
52910 PyObject * obj1 = 0 ;
52911 PyObject * obj2 = 0 ;
52912 char * kwnames[] = {
52913 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52914 };
52915
52916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52918 if (!SWIG_IsOK(res1)) {
52919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52920 }
52921 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52923 if (!SWIG_IsOK(res2)) {
52924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52925 }
52926 arg2 = reinterpret_cast< wxWindow * >(argp2);
52927 if (obj2) {
52928 ecode3 = SWIG_AsVal_int(obj2, &val3);
52929 if (!SWIG_IsOK(ecode3)) {
52930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52931 }
52932 arg3 = static_cast< int >(val3);
52933 }
52934 {
52935 PyThreadState* __tstate = wxPyBeginAllowThreads();
52936 (arg1)->RightOf(arg2,arg3);
52937 wxPyEndAllowThreads(__tstate);
52938 if (PyErr_Occurred()) SWIG_fail;
52939 }
52940 resultobj = SWIG_Py_Void();
52941 return resultobj;
52942 fail:
52943 return NULL;
52944 }
52945
52946
52947 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52948 PyObject *resultobj = 0;
52949 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52950 wxWindow *arg2 = (wxWindow *) 0 ;
52951 int arg3 = (int) 0 ;
52952 void *argp1 = 0 ;
52953 int res1 = 0 ;
52954 void *argp2 = 0 ;
52955 int res2 = 0 ;
52956 int val3 ;
52957 int ecode3 = 0 ;
52958 PyObject * obj0 = 0 ;
52959 PyObject * obj1 = 0 ;
52960 PyObject * obj2 = 0 ;
52961 char * kwnames[] = {
52962 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52963 };
52964
52965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52967 if (!SWIG_IsOK(res1)) {
52968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52969 }
52970 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52971 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52972 if (!SWIG_IsOK(res2)) {
52973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52974 }
52975 arg2 = reinterpret_cast< wxWindow * >(argp2);
52976 if (obj2) {
52977 ecode3 = SWIG_AsVal_int(obj2, &val3);
52978 if (!SWIG_IsOK(ecode3)) {
52979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52980 }
52981 arg3 = static_cast< int >(val3);
52982 }
52983 {
52984 PyThreadState* __tstate = wxPyBeginAllowThreads();
52985 (arg1)->Above(arg2,arg3);
52986 wxPyEndAllowThreads(__tstate);
52987 if (PyErr_Occurred()) SWIG_fail;
52988 }
52989 resultobj = SWIG_Py_Void();
52990 return resultobj;
52991 fail:
52992 return NULL;
52993 }
52994
52995
52996 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52997 PyObject *resultobj = 0;
52998 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52999 wxWindow *arg2 = (wxWindow *) 0 ;
53000 int arg3 = (int) 0 ;
53001 void *argp1 = 0 ;
53002 int res1 = 0 ;
53003 void *argp2 = 0 ;
53004 int res2 = 0 ;
53005 int val3 ;
53006 int ecode3 = 0 ;
53007 PyObject * obj0 = 0 ;
53008 PyObject * obj1 = 0 ;
53009 PyObject * obj2 = 0 ;
53010 char * kwnames[] = {
53011 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53012 };
53013
53014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53016 if (!SWIG_IsOK(res1)) {
53017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53018 }
53019 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53021 if (!SWIG_IsOK(res2)) {
53022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53023 }
53024 arg2 = reinterpret_cast< wxWindow * >(argp2);
53025 if (obj2) {
53026 ecode3 = SWIG_AsVal_int(obj2, &val3);
53027 if (!SWIG_IsOK(ecode3)) {
53028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53029 }
53030 arg3 = static_cast< int >(val3);
53031 }
53032 {
53033 PyThreadState* __tstate = wxPyBeginAllowThreads();
53034 (arg1)->Below(arg2,arg3);
53035 wxPyEndAllowThreads(__tstate);
53036 if (PyErr_Occurred()) SWIG_fail;
53037 }
53038 resultobj = SWIG_Py_Void();
53039 return resultobj;
53040 fail:
53041 return NULL;
53042 }
53043
53044
53045 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53046 PyObject *resultobj = 0;
53047 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53048 wxWindow *arg2 = (wxWindow *) 0 ;
53049 wxEdge arg3 ;
53050 int arg4 = (int) 0 ;
53051 void *argp1 = 0 ;
53052 int res1 = 0 ;
53053 void *argp2 = 0 ;
53054 int res2 = 0 ;
53055 int val3 ;
53056 int ecode3 = 0 ;
53057 int val4 ;
53058 int ecode4 = 0 ;
53059 PyObject * obj0 = 0 ;
53060 PyObject * obj1 = 0 ;
53061 PyObject * obj2 = 0 ;
53062 PyObject * obj3 = 0 ;
53063 char * kwnames[] = {
53064 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53065 };
53066
53067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53069 if (!SWIG_IsOK(res1)) {
53070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53071 }
53072 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53074 if (!SWIG_IsOK(res2)) {
53075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53076 }
53077 arg2 = reinterpret_cast< wxWindow * >(argp2);
53078 ecode3 = SWIG_AsVal_int(obj2, &val3);
53079 if (!SWIG_IsOK(ecode3)) {
53080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53081 }
53082 arg3 = static_cast< wxEdge >(val3);
53083 if (obj3) {
53084 ecode4 = SWIG_AsVal_int(obj3, &val4);
53085 if (!SWIG_IsOK(ecode4)) {
53086 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53087 }
53088 arg4 = static_cast< int >(val4);
53089 }
53090 {
53091 PyThreadState* __tstate = wxPyBeginAllowThreads();
53092 (arg1)->SameAs(arg2,arg3,arg4);
53093 wxPyEndAllowThreads(__tstate);
53094 if (PyErr_Occurred()) SWIG_fail;
53095 }
53096 resultobj = SWIG_Py_Void();
53097 return resultobj;
53098 fail:
53099 return NULL;
53100 }
53101
53102
53103 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53104 PyObject *resultobj = 0;
53105 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53106 wxWindow *arg2 = (wxWindow *) 0 ;
53107 wxEdge arg3 ;
53108 int arg4 ;
53109 void *argp1 = 0 ;
53110 int res1 = 0 ;
53111 void *argp2 = 0 ;
53112 int res2 = 0 ;
53113 int val3 ;
53114 int ecode3 = 0 ;
53115 int val4 ;
53116 int ecode4 = 0 ;
53117 PyObject * obj0 = 0 ;
53118 PyObject * obj1 = 0 ;
53119 PyObject * obj2 = 0 ;
53120 PyObject * obj3 = 0 ;
53121 char * kwnames[] = {
53122 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53123 };
53124
53125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53127 if (!SWIG_IsOK(res1)) {
53128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53129 }
53130 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53131 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53132 if (!SWIG_IsOK(res2)) {
53133 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53134 }
53135 arg2 = reinterpret_cast< wxWindow * >(argp2);
53136 ecode3 = SWIG_AsVal_int(obj2, &val3);
53137 if (!SWIG_IsOK(ecode3)) {
53138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53139 }
53140 arg3 = static_cast< wxEdge >(val3);
53141 ecode4 = SWIG_AsVal_int(obj3, &val4);
53142 if (!SWIG_IsOK(ecode4)) {
53143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53144 }
53145 arg4 = static_cast< int >(val4);
53146 {
53147 PyThreadState* __tstate = wxPyBeginAllowThreads();
53148 (arg1)->PercentOf(arg2,arg3,arg4);
53149 wxPyEndAllowThreads(__tstate);
53150 if (PyErr_Occurred()) SWIG_fail;
53151 }
53152 resultobj = SWIG_Py_Void();
53153 return resultobj;
53154 fail:
53155 return NULL;
53156 }
53157
53158
53159 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53160 PyObject *resultobj = 0;
53161 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53162 int arg2 ;
53163 void *argp1 = 0 ;
53164 int res1 = 0 ;
53165 int val2 ;
53166 int ecode2 = 0 ;
53167 PyObject * obj0 = 0 ;
53168 PyObject * obj1 = 0 ;
53169 char * kwnames[] = {
53170 (char *) "self",(char *) "val", NULL
53171 };
53172
53173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53175 if (!SWIG_IsOK(res1)) {
53176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53177 }
53178 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53179 ecode2 = SWIG_AsVal_int(obj1, &val2);
53180 if (!SWIG_IsOK(ecode2)) {
53181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53182 }
53183 arg2 = static_cast< int >(val2);
53184 {
53185 PyThreadState* __tstate = wxPyBeginAllowThreads();
53186 (arg1)->Absolute(arg2);
53187 wxPyEndAllowThreads(__tstate);
53188 if (PyErr_Occurred()) SWIG_fail;
53189 }
53190 resultobj = SWIG_Py_Void();
53191 return resultobj;
53192 fail:
53193 return NULL;
53194 }
53195
53196
53197 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53198 PyObject *resultobj = 0;
53199 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53200 void *argp1 = 0 ;
53201 int res1 = 0 ;
53202 PyObject *swig_obj[1] ;
53203
53204 if (!args) SWIG_fail;
53205 swig_obj[0] = args;
53206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53207 if (!SWIG_IsOK(res1)) {
53208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53209 }
53210 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53211 {
53212 PyThreadState* __tstate = wxPyBeginAllowThreads();
53213 (arg1)->Unconstrained();
53214 wxPyEndAllowThreads(__tstate);
53215 if (PyErr_Occurred()) SWIG_fail;
53216 }
53217 resultobj = SWIG_Py_Void();
53218 return resultobj;
53219 fail:
53220 return NULL;
53221 }
53222
53223
53224 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53225 PyObject *resultobj = 0;
53226 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53227 void *argp1 = 0 ;
53228 int res1 = 0 ;
53229 PyObject *swig_obj[1] ;
53230
53231 if (!args) SWIG_fail;
53232 swig_obj[0] = args;
53233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53234 if (!SWIG_IsOK(res1)) {
53235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53236 }
53237 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53238 {
53239 PyThreadState* __tstate = wxPyBeginAllowThreads();
53240 (arg1)->AsIs();
53241 wxPyEndAllowThreads(__tstate);
53242 if (PyErr_Occurred()) SWIG_fail;
53243 }
53244 resultobj = SWIG_Py_Void();
53245 return resultobj;
53246 fail:
53247 return NULL;
53248 }
53249
53250
53251 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53252 PyObject *resultobj = 0;
53253 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53254 wxWindow *result = 0 ;
53255 void *argp1 = 0 ;
53256 int res1 = 0 ;
53257 PyObject *swig_obj[1] ;
53258
53259 if (!args) SWIG_fail;
53260 swig_obj[0] = args;
53261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53262 if (!SWIG_IsOK(res1)) {
53263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53264 }
53265 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53266 {
53267 PyThreadState* __tstate = wxPyBeginAllowThreads();
53268 result = (wxWindow *)(arg1)->GetOtherWindow();
53269 wxPyEndAllowThreads(__tstate);
53270 if (PyErr_Occurred()) SWIG_fail;
53271 }
53272 {
53273 resultobj = wxPyMake_wxObject(result, 0);
53274 }
53275 return resultobj;
53276 fail:
53277 return NULL;
53278 }
53279
53280
53281 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53282 PyObject *resultobj = 0;
53283 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53284 wxEdge result;
53285 void *argp1 = 0 ;
53286 int res1 = 0 ;
53287 PyObject *swig_obj[1] ;
53288
53289 if (!args) SWIG_fail;
53290 swig_obj[0] = args;
53291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53292 if (!SWIG_IsOK(res1)) {
53293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53294 }
53295 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53296 {
53297 PyThreadState* __tstate = wxPyBeginAllowThreads();
53298 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53299 wxPyEndAllowThreads(__tstate);
53300 if (PyErr_Occurred()) SWIG_fail;
53301 }
53302 resultobj = SWIG_From_int(static_cast< int >(result));
53303 return resultobj;
53304 fail:
53305 return NULL;
53306 }
53307
53308
53309 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53310 PyObject *resultobj = 0;
53311 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53312 wxEdge arg2 ;
53313 void *argp1 = 0 ;
53314 int res1 = 0 ;
53315 int val2 ;
53316 int ecode2 = 0 ;
53317 PyObject * obj0 = 0 ;
53318 PyObject * obj1 = 0 ;
53319 char * kwnames[] = {
53320 (char *) "self",(char *) "which", NULL
53321 };
53322
53323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53325 if (!SWIG_IsOK(res1)) {
53326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53327 }
53328 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53329 ecode2 = SWIG_AsVal_int(obj1, &val2);
53330 if (!SWIG_IsOK(ecode2)) {
53331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53332 }
53333 arg2 = static_cast< wxEdge >(val2);
53334 {
53335 PyThreadState* __tstate = wxPyBeginAllowThreads();
53336 (arg1)->SetEdge(arg2);
53337 wxPyEndAllowThreads(__tstate);
53338 if (PyErr_Occurred()) SWIG_fail;
53339 }
53340 resultobj = SWIG_Py_Void();
53341 return resultobj;
53342 fail:
53343 return NULL;
53344 }
53345
53346
53347 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53348 PyObject *resultobj = 0;
53349 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53350 int arg2 ;
53351 void *argp1 = 0 ;
53352 int res1 = 0 ;
53353 int val2 ;
53354 int ecode2 = 0 ;
53355 PyObject * obj0 = 0 ;
53356 PyObject * obj1 = 0 ;
53357 char * kwnames[] = {
53358 (char *) "self",(char *) "v", NULL
53359 };
53360
53361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53363 if (!SWIG_IsOK(res1)) {
53364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53365 }
53366 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53367 ecode2 = SWIG_AsVal_int(obj1, &val2);
53368 if (!SWIG_IsOK(ecode2)) {
53369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53370 }
53371 arg2 = static_cast< int >(val2);
53372 {
53373 PyThreadState* __tstate = wxPyBeginAllowThreads();
53374 (arg1)->SetValue(arg2);
53375 wxPyEndAllowThreads(__tstate);
53376 if (PyErr_Occurred()) SWIG_fail;
53377 }
53378 resultobj = SWIG_Py_Void();
53379 return resultobj;
53380 fail:
53381 return NULL;
53382 }
53383
53384
53385 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53386 PyObject *resultobj = 0;
53387 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53388 int result;
53389 void *argp1 = 0 ;
53390 int res1 = 0 ;
53391 PyObject *swig_obj[1] ;
53392
53393 if (!args) SWIG_fail;
53394 swig_obj[0] = args;
53395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53396 if (!SWIG_IsOK(res1)) {
53397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53398 }
53399 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53400 {
53401 PyThreadState* __tstate = wxPyBeginAllowThreads();
53402 result = (int)(arg1)->GetMargin();
53403 wxPyEndAllowThreads(__tstate);
53404 if (PyErr_Occurred()) SWIG_fail;
53405 }
53406 resultobj = SWIG_From_int(static_cast< int >(result));
53407 return resultobj;
53408 fail:
53409 return NULL;
53410 }
53411
53412
53413 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53414 PyObject *resultobj = 0;
53415 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53416 int arg2 ;
53417 void *argp1 = 0 ;
53418 int res1 = 0 ;
53419 int val2 ;
53420 int ecode2 = 0 ;
53421 PyObject * obj0 = 0 ;
53422 PyObject * obj1 = 0 ;
53423 char * kwnames[] = {
53424 (char *) "self",(char *) "m", NULL
53425 };
53426
53427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53429 if (!SWIG_IsOK(res1)) {
53430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53431 }
53432 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53433 ecode2 = SWIG_AsVal_int(obj1, &val2);
53434 if (!SWIG_IsOK(ecode2)) {
53435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53436 }
53437 arg2 = static_cast< int >(val2);
53438 {
53439 PyThreadState* __tstate = wxPyBeginAllowThreads();
53440 (arg1)->SetMargin(arg2);
53441 wxPyEndAllowThreads(__tstate);
53442 if (PyErr_Occurred()) SWIG_fail;
53443 }
53444 resultobj = SWIG_Py_Void();
53445 return resultobj;
53446 fail:
53447 return NULL;
53448 }
53449
53450
53451 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53452 PyObject *resultobj = 0;
53453 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53454 int result;
53455 void *argp1 = 0 ;
53456 int res1 = 0 ;
53457 PyObject *swig_obj[1] ;
53458
53459 if (!args) SWIG_fail;
53460 swig_obj[0] = args;
53461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53462 if (!SWIG_IsOK(res1)) {
53463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53464 }
53465 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53466 {
53467 PyThreadState* __tstate = wxPyBeginAllowThreads();
53468 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53469 wxPyEndAllowThreads(__tstate);
53470 if (PyErr_Occurred()) SWIG_fail;
53471 }
53472 resultobj = SWIG_From_int(static_cast< int >(result));
53473 return resultobj;
53474 fail:
53475 return NULL;
53476 }
53477
53478
53479 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53480 PyObject *resultobj = 0;
53481 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53482 int result;
53483 void *argp1 = 0 ;
53484 int res1 = 0 ;
53485 PyObject *swig_obj[1] ;
53486
53487 if (!args) SWIG_fail;
53488 swig_obj[0] = args;
53489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53490 if (!SWIG_IsOK(res1)) {
53491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53492 }
53493 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53494 {
53495 PyThreadState* __tstate = wxPyBeginAllowThreads();
53496 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53497 wxPyEndAllowThreads(__tstate);
53498 if (PyErr_Occurred()) SWIG_fail;
53499 }
53500 resultobj = SWIG_From_int(static_cast< int >(result));
53501 return resultobj;
53502 fail:
53503 return NULL;
53504 }
53505
53506
53507 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53508 PyObject *resultobj = 0;
53509 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53510 int result;
53511 void *argp1 = 0 ;
53512 int res1 = 0 ;
53513 PyObject *swig_obj[1] ;
53514
53515 if (!args) SWIG_fail;
53516 swig_obj[0] = args;
53517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53518 if (!SWIG_IsOK(res1)) {
53519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53520 }
53521 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53522 {
53523 PyThreadState* __tstate = wxPyBeginAllowThreads();
53524 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53525 wxPyEndAllowThreads(__tstate);
53526 if (PyErr_Occurred()) SWIG_fail;
53527 }
53528 resultobj = SWIG_From_int(static_cast< int >(result));
53529 return resultobj;
53530 fail:
53531 return NULL;
53532 }
53533
53534
53535 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53536 PyObject *resultobj = 0;
53537 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53538 bool result;
53539 void *argp1 = 0 ;
53540 int res1 = 0 ;
53541 PyObject *swig_obj[1] ;
53542
53543 if (!args) SWIG_fail;
53544 swig_obj[0] = args;
53545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53546 if (!SWIG_IsOK(res1)) {
53547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53548 }
53549 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53550 {
53551 PyThreadState* __tstate = wxPyBeginAllowThreads();
53552 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53553 wxPyEndAllowThreads(__tstate);
53554 if (PyErr_Occurred()) SWIG_fail;
53555 }
53556 {
53557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53558 }
53559 return resultobj;
53560 fail:
53561 return NULL;
53562 }
53563
53564
53565 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53566 PyObject *resultobj = 0;
53567 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53568 bool arg2 ;
53569 void *argp1 = 0 ;
53570 int res1 = 0 ;
53571 bool val2 ;
53572 int ecode2 = 0 ;
53573 PyObject * obj0 = 0 ;
53574 PyObject * obj1 = 0 ;
53575 char * kwnames[] = {
53576 (char *) "self",(char *) "d", NULL
53577 };
53578
53579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53581 if (!SWIG_IsOK(res1)) {
53582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53583 }
53584 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53585 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53586 if (!SWIG_IsOK(ecode2)) {
53587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53588 }
53589 arg2 = static_cast< bool >(val2);
53590 {
53591 PyThreadState* __tstate = wxPyBeginAllowThreads();
53592 (arg1)->SetDone(arg2);
53593 wxPyEndAllowThreads(__tstate);
53594 if (PyErr_Occurred()) SWIG_fail;
53595 }
53596 resultobj = SWIG_Py_Void();
53597 return resultobj;
53598 fail:
53599 return NULL;
53600 }
53601
53602
53603 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53604 PyObject *resultobj = 0;
53605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53606 wxRelationship result;
53607 void *argp1 = 0 ;
53608 int res1 = 0 ;
53609 PyObject *swig_obj[1] ;
53610
53611 if (!args) SWIG_fail;
53612 swig_obj[0] = args;
53613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53614 if (!SWIG_IsOK(res1)) {
53615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53616 }
53617 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53618 {
53619 PyThreadState* __tstate = wxPyBeginAllowThreads();
53620 result = (wxRelationship)(arg1)->GetRelationship();
53621 wxPyEndAllowThreads(__tstate);
53622 if (PyErr_Occurred()) SWIG_fail;
53623 }
53624 resultobj = SWIG_From_int(static_cast< int >(result));
53625 return resultobj;
53626 fail:
53627 return NULL;
53628 }
53629
53630
53631 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53632 PyObject *resultobj = 0;
53633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53634 wxRelationship arg2 ;
53635 void *argp1 = 0 ;
53636 int res1 = 0 ;
53637 int val2 ;
53638 int ecode2 = 0 ;
53639 PyObject * obj0 = 0 ;
53640 PyObject * obj1 = 0 ;
53641 char * kwnames[] = {
53642 (char *) "self",(char *) "r", NULL
53643 };
53644
53645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53647 if (!SWIG_IsOK(res1)) {
53648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53649 }
53650 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53651 ecode2 = SWIG_AsVal_int(obj1, &val2);
53652 if (!SWIG_IsOK(ecode2)) {
53653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53654 }
53655 arg2 = static_cast< wxRelationship >(val2);
53656 {
53657 PyThreadState* __tstate = wxPyBeginAllowThreads();
53658 (arg1)->SetRelationship(arg2);
53659 wxPyEndAllowThreads(__tstate);
53660 if (PyErr_Occurred()) SWIG_fail;
53661 }
53662 resultobj = SWIG_Py_Void();
53663 return resultobj;
53664 fail:
53665 return NULL;
53666 }
53667
53668
53669 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53670 PyObject *resultobj = 0;
53671 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53672 wxWindow *arg2 = (wxWindow *) 0 ;
53673 bool result;
53674 void *argp1 = 0 ;
53675 int res1 = 0 ;
53676 void *argp2 = 0 ;
53677 int res2 = 0 ;
53678 PyObject * obj0 = 0 ;
53679 PyObject * obj1 = 0 ;
53680 char * kwnames[] = {
53681 (char *) "self",(char *) "otherW", NULL
53682 };
53683
53684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53686 if (!SWIG_IsOK(res1)) {
53687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53688 }
53689 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53691 if (!SWIG_IsOK(res2)) {
53692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53693 }
53694 arg2 = reinterpret_cast< wxWindow * >(argp2);
53695 {
53696 PyThreadState* __tstate = wxPyBeginAllowThreads();
53697 result = (bool)(arg1)->ResetIfWin(arg2);
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_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53711 PyObject *resultobj = 0;
53712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53713 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53714 wxWindow *arg3 = (wxWindow *) 0 ;
53715 bool result;
53716 void *argp1 = 0 ;
53717 int res1 = 0 ;
53718 void *argp2 = 0 ;
53719 int res2 = 0 ;
53720 void *argp3 = 0 ;
53721 int res3 = 0 ;
53722 PyObject * obj0 = 0 ;
53723 PyObject * obj1 = 0 ;
53724 PyObject * obj2 = 0 ;
53725 char * kwnames[] = {
53726 (char *) "self",(char *) "constraints",(char *) "win", NULL
53727 };
53728
53729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53731 if (!SWIG_IsOK(res1)) {
53732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53733 }
53734 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53735 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53736 if (!SWIG_IsOK(res2)) {
53737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53738 }
53739 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53740 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53741 if (!SWIG_IsOK(res3)) {
53742 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53743 }
53744 arg3 = reinterpret_cast< wxWindow * >(argp3);
53745 {
53746 PyThreadState* __tstate = wxPyBeginAllowThreads();
53747 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53748 wxPyEndAllowThreads(__tstate);
53749 if (PyErr_Occurred()) SWIG_fail;
53750 }
53751 {
53752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53753 }
53754 return resultobj;
53755 fail:
53756 return NULL;
53757 }
53758
53759
53760 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53761 PyObject *resultobj = 0;
53762 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53763 wxEdge arg2 ;
53764 wxWindow *arg3 = (wxWindow *) 0 ;
53765 wxWindow *arg4 = (wxWindow *) 0 ;
53766 int result;
53767 void *argp1 = 0 ;
53768 int res1 = 0 ;
53769 int val2 ;
53770 int ecode2 = 0 ;
53771 void *argp3 = 0 ;
53772 int res3 = 0 ;
53773 void *argp4 = 0 ;
53774 int res4 = 0 ;
53775 PyObject * obj0 = 0 ;
53776 PyObject * obj1 = 0 ;
53777 PyObject * obj2 = 0 ;
53778 PyObject * obj3 = 0 ;
53779 char * kwnames[] = {
53780 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53781 };
53782
53783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53785 if (!SWIG_IsOK(res1)) {
53786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53787 }
53788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53789 ecode2 = SWIG_AsVal_int(obj1, &val2);
53790 if (!SWIG_IsOK(ecode2)) {
53791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53792 }
53793 arg2 = static_cast< wxEdge >(val2);
53794 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53795 if (!SWIG_IsOK(res3)) {
53796 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53797 }
53798 arg3 = reinterpret_cast< wxWindow * >(argp3);
53799 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53800 if (!SWIG_IsOK(res4)) {
53801 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53802 }
53803 arg4 = reinterpret_cast< wxWindow * >(argp4);
53804 {
53805 PyThreadState* __tstate = wxPyBeginAllowThreads();
53806 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53807 wxPyEndAllowThreads(__tstate);
53808 if (PyErr_Occurred()) SWIG_fail;
53809 }
53810 resultobj = SWIG_From_int(static_cast< int >(result));
53811 return resultobj;
53812 fail:
53813 return NULL;
53814 }
53815
53816
53817 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53818 PyObject *obj;
53819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53820 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53821 return SWIG_Py_Void();
53822 }
53823
53824 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53825 PyObject *resultobj = 0;
53826 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53827 wxIndividualLayoutConstraint *result = 0 ;
53828 void *argp1 = 0 ;
53829 int res1 = 0 ;
53830 PyObject *swig_obj[1] ;
53831
53832 if (!args) SWIG_fail;
53833 swig_obj[0] = args;
53834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53835 if (!SWIG_IsOK(res1)) {
53836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53837 }
53838 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53839 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53841 return resultobj;
53842 fail:
53843 return NULL;
53844 }
53845
53846
53847 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53848 PyObject *resultobj = 0;
53849 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53850 wxIndividualLayoutConstraint *result = 0 ;
53851 void *argp1 = 0 ;
53852 int res1 = 0 ;
53853 PyObject *swig_obj[1] ;
53854
53855 if (!args) SWIG_fail;
53856 swig_obj[0] = args;
53857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53858 if (!SWIG_IsOK(res1)) {
53859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53860 }
53861 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53862 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53864 return resultobj;
53865 fail:
53866 return NULL;
53867 }
53868
53869
53870 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53871 PyObject *resultobj = 0;
53872 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53873 wxIndividualLayoutConstraint *result = 0 ;
53874 void *argp1 = 0 ;
53875 int res1 = 0 ;
53876 PyObject *swig_obj[1] ;
53877
53878 if (!args) SWIG_fail;
53879 swig_obj[0] = args;
53880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53881 if (!SWIG_IsOK(res1)) {
53882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53883 }
53884 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53885 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53887 return resultobj;
53888 fail:
53889 return NULL;
53890 }
53891
53892
53893 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53894 PyObject *resultobj = 0;
53895 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53896 wxIndividualLayoutConstraint *result = 0 ;
53897 void *argp1 = 0 ;
53898 int res1 = 0 ;
53899 PyObject *swig_obj[1] ;
53900
53901 if (!args) SWIG_fail;
53902 swig_obj[0] = args;
53903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53904 if (!SWIG_IsOK(res1)) {
53905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53906 }
53907 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53908 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53910 return resultobj;
53911 fail:
53912 return NULL;
53913 }
53914
53915
53916 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53917 PyObject *resultobj = 0;
53918 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53919 wxIndividualLayoutConstraint *result = 0 ;
53920 void *argp1 = 0 ;
53921 int res1 = 0 ;
53922 PyObject *swig_obj[1] ;
53923
53924 if (!args) SWIG_fail;
53925 swig_obj[0] = args;
53926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53927 if (!SWIG_IsOK(res1)) {
53928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53929 }
53930 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53931 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53933 return resultobj;
53934 fail:
53935 return NULL;
53936 }
53937
53938
53939 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53940 PyObject *resultobj = 0;
53941 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53942 wxIndividualLayoutConstraint *result = 0 ;
53943 void *argp1 = 0 ;
53944 int res1 = 0 ;
53945 PyObject *swig_obj[1] ;
53946
53947 if (!args) SWIG_fail;
53948 swig_obj[0] = args;
53949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53950 if (!SWIG_IsOK(res1)) {
53951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53952 }
53953 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53954 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53956 return resultobj;
53957 fail:
53958 return NULL;
53959 }
53960
53961
53962 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53963 PyObject *resultobj = 0;
53964 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53965 wxIndividualLayoutConstraint *result = 0 ;
53966 void *argp1 = 0 ;
53967 int res1 = 0 ;
53968 PyObject *swig_obj[1] ;
53969
53970 if (!args) SWIG_fail;
53971 swig_obj[0] = args;
53972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53973 if (!SWIG_IsOK(res1)) {
53974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53975 }
53976 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53977 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53979 return resultobj;
53980 fail:
53981 return NULL;
53982 }
53983
53984
53985 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53986 PyObject *resultobj = 0;
53987 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53988 wxIndividualLayoutConstraint *result = 0 ;
53989 void *argp1 = 0 ;
53990 int res1 = 0 ;
53991 PyObject *swig_obj[1] ;
53992
53993 if (!args) SWIG_fail;
53994 swig_obj[0] = args;
53995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53996 if (!SWIG_IsOK(res1)) {
53997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53998 }
53999 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54000 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54002 return resultobj;
54003 fail:
54004 return NULL;
54005 }
54006
54007
54008 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54009 PyObject *resultobj = 0;
54010 wxLayoutConstraints *result = 0 ;
54011
54012 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54013 {
54014 PyThreadState* __tstate = wxPyBeginAllowThreads();
54015 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54016 wxPyEndAllowThreads(__tstate);
54017 if (PyErr_Occurred()) SWIG_fail;
54018 }
54019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54020 return resultobj;
54021 fail:
54022 return NULL;
54023 }
54024
54025
54026 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54027 PyObject *resultobj = 0;
54028 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54029 void *argp1 = 0 ;
54030 int res1 = 0 ;
54031 PyObject *swig_obj[1] ;
54032
54033 if (!args) SWIG_fail;
54034 swig_obj[0] = args;
54035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54036 if (!SWIG_IsOK(res1)) {
54037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54038 }
54039 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54040 {
54041 PyThreadState* __tstate = wxPyBeginAllowThreads();
54042 delete arg1;
54043
54044 wxPyEndAllowThreads(__tstate);
54045 if (PyErr_Occurred()) SWIG_fail;
54046 }
54047 resultobj = SWIG_Py_Void();
54048 return resultobj;
54049 fail:
54050 return NULL;
54051 }
54052
54053
54054 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54055 PyObject *resultobj = 0;
54056 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54057 wxWindow *arg2 = (wxWindow *) 0 ;
54058 int *arg3 = (int *) 0 ;
54059 bool result;
54060 void *argp1 = 0 ;
54061 int res1 = 0 ;
54062 void *argp2 = 0 ;
54063 int res2 = 0 ;
54064 int temp3 ;
54065 int res3 = SWIG_TMPOBJ ;
54066 PyObject * obj0 = 0 ;
54067 PyObject * obj1 = 0 ;
54068 char * kwnames[] = {
54069 (char *) "self",(char *) "win", NULL
54070 };
54071
54072 arg3 = &temp3;
54073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54075 if (!SWIG_IsOK(res1)) {
54076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54077 }
54078 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54080 if (!SWIG_IsOK(res2)) {
54081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54082 }
54083 arg2 = reinterpret_cast< wxWindow * >(argp2);
54084 {
54085 PyThreadState* __tstate = wxPyBeginAllowThreads();
54086 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54087 wxPyEndAllowThreads(__tstate);
54088 if (PyErr_Occurred()) SWIG_fail;
54089 }
54090 {
54091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54092 }
54093 if (SWIG_IsTmpObj(res3)) {
54094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54095 } else {
54096 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54097 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54098 }
54099 return resultobj;
54100 fail:
54101 return NULL;
54102 }
54103
54104
54105 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54106 PyObject *resultobj = 0;
54107 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54108 bool result;
54109 void *argp1 = 0 ;
54110 int res1 = 0 ;
54111 PyObject *swig_obj[1] ;
54112
54113 if (!args) SWIG_fail;
54114 swig_obj[0] = args;
54115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54116 if (!SWIG_IsOK(res1)) {
54117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54118 }
54119 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54120 {
54121 PyThreadState* __tstate = wxPyBeginAllowThreads();
54122 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54123 wxPyEndAllowThreads(__tstate);
54124 if (PyErr_Occurred()) SWIG_fail;
54125 }
54126 {
54127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54128 }
54129 return resultobj;
54130 fail:
54131 return NULL;
54132 }
54133
54134
54135 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54136 PyObject *obj;
54137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54138 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54139 return SWIG_Py_Void();
54140 }
54141
54142 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54143 return SWIG_Python_InitShadowInstance(args);
54144 }
54145
54146 static PyMethodDef SwigMethods[] = {
54147 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54148 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54149 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54150 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54151 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54152 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54153 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54154 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54155 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54157 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54170 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54171 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54172 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54174 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54175 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54176 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54177 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54178 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54179 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54180 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54182 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54188 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54189 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54190 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54191 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54192 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54193 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54194 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54196 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54204 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54205 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54206 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54211 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54212 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54214 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54216 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54218 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54220 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54222 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54224 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54225 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54227 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54229 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54231 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54233 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54234 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54235 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54236 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54238 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54240 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54256 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54257 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54258 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54259 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54260 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54261 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54262 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54263 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54265 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54266 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54267 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54272 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54273 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54274 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54275 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54276 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54280 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54282 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54287 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54289 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54290 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54291 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54292 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54293 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54294 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54295 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54296 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54298 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54299 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54300 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54301 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54302 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54306 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54307 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54308 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54309 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54310 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54311 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54314 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54315 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54316 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54318 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54319 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54321 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54322 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54323 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54324 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54325 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54326 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54327 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54328 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54329 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54330 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54331 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54332 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54337 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54342 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54343 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54344 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54345 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54346 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54348 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54351 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54354 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54357 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54358 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54359 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54360 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54362 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54363 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54364 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54365 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54368 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54369 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54370 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54374 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54379 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54380 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54381 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54382 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54383 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54384 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54385 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54392 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54393 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54395 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54397 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54403 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54404 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54405 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54406 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54407 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54408 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54409 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54410 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54411 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54412 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54413 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54415 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54416 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54417 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54418 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54419 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54420 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54421 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54422 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54424 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54433 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54445 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54450 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54451 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54466 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54467 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54468 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54469 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54472 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54473 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54474 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54476 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54478 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54480 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54483 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54484 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54485 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54486 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54488 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54504 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54505 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54506 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54512 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54513 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54515 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54516 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54517 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54518 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54519 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54520 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54521 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54522 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54523 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54524 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54525 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54526 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54527 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54528 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54529 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54530 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54531 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54532 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54533 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54534 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54535 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54536 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54537 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54538 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54539 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54540 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54541 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54542 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54543 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54544 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54545 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54546 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54547 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54549 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54550 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54551 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54552 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54555 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54556 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54559 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54563 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54564 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54565 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54566 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54568 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54569 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54571 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54573 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54575 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54577 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54578 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54579 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54581 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54582 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54584 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54585 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54586 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54588 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54589 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54590 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54592 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54594 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54595 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54596 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54598 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54600 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54601 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54603 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54604 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54605 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54607 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54608 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54609 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54610 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54611 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54613 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54614 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54617 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54618 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54620 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54621 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54624 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54625 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54627 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54633 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54634 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54635 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54636 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54637 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54638 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54639 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54640 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54641 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54642 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54643 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54644 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54645 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54646 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54647 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54648 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54649 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54650 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54651 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54652 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54653 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54654 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54655 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54656 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54658 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54659 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54660 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54661 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54662 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54663 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54664 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54665 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54666 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54667 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54668 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54669 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54670 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54671 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54672 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54673 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54674 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54675 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54676 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54677 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54678 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54679 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54680 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54681 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54682 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54683 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54684 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54685 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54686 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54687 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54688 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54689 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54690 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54691 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54692 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54694 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54695 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54696 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54697 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54699 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54700 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54701 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54702 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54703 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54704 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54705 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54706 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54707 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54709 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54710 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54711 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54712 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54713 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54714 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54715 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54716 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54717 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54718 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54719 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54720 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54721 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54722 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54723 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54724 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54725 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54726 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54727 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54728 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54729 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54730 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54731 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54732 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54733 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54734 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54735 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54736 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54738 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54739 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54742 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54743 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54744 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54745 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54746 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54747 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54749 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54750 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54753 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54754 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54756 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54757 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54759 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54760 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54761 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54762 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54763 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54764 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54766 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54768 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54769 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54771 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54772 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54773 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54775 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54776 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54777 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54779 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54780 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54782 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54783 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54784 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54785 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54786 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54789 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54791 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54793 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54794 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54795 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54798 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54799 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54800 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54802 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54803 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54804 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54806 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54807 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54808 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54809 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54810 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54811 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54812 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54813 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54814 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54815 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54816 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54817 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54818 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54819 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54820 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54821 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54826 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54828 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54830 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54831 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54832 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54833 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54834 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54835 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54837 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54838 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54839 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54841 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54842 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54843 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54844 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54845 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54848 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54849 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54850 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54853 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54854 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54855 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54856 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54857 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54859 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54861 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54864 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54866 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54867 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54869 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54870 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54871 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54873 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54874 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54875 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54877 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54879 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54880 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54881 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54883 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54885 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54887 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54888 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54890 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54891 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54893 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54895 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54896 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54897 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54899 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54901 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54902 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54903 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54905 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54907 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54908 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54909 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54910 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54912 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54914 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54916 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54918 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54919 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54921 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54922 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54923 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54924 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54925 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54926 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54927 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54928 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54929 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54931 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54933 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54935 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54937 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54938 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54939 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54941 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54942 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54943 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54944 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54945 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54946 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54948 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54952 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54953 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54954 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54955 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54956 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54957 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54958 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54959 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54961 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54963 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54964 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54966 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54967 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54968 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54969 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54971 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54972 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54973 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54974 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54976 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54977 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54979 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54980 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54981 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54983 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54986 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54987 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54988 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54989 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54990 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54992 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54993 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54995 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54996 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54997 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54998 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55000 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55001 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55002 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55003 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55004 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55005 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55006 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55007 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55008 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55009 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55011 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55014 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55015 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55016 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55018 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55020 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55022 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55024 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55025 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55028 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55038 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55039 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55043 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55044 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55045 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55046 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55047 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55048 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55049 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55050 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55051 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55052 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55053 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55054 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55055 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55056 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55057 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55059 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55060 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55063 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55064 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55069 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55070 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55071 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55073 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55074 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55075 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55076 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55077 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55078 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55079 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55080 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55081 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55083 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55085 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55086 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55087 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55088 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55090 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55092 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55094 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55097 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55098 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55099 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55100 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55101 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55102 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55104 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55106 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55107 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55108 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55109 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55116 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55121 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55122 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55123 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55124 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55125 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55126 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55128 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55130 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55131 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55132 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55138 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55139 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55140 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55141 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55144 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55145 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55146 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55147 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55148 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55150 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55151 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55155 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55161 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55162 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55163 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55164 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55165 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55166 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55167 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55169 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55172 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55173 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55174 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55175 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55176 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55185 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55189 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55190 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55192 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55193 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55200 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55202 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55203 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55204 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55205 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55209 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55212 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55213 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55214 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55217 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55219 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55220 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55222 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55223 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55224 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55225 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55226 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55227 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55228 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55229 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55230 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55231 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55232 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55234 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55235 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55236 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55237 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55238 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55239 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55240 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55241 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55242 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55243 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55244 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55246 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55247 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55248 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55249 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55250 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55251 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55252 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55254 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55255 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55261 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55262 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55263 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55265 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55269 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55275 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55276 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55277 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55278 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55280 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55281 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55289 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55291 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55294 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55296 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55297 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55298 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55299 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55301 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55303 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55304 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55306 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55307 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55308 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55312 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55313 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55314 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55315 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55316 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55317 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55323 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55325 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55326 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55331 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55332 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55334 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55335 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55337 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55338 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55339 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55340 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55341 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55342 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55343 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55345 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55346 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55348 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55349 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55351 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55354 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55355 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55357 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55359 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55361 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55362 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55364 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55365 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55366 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55368 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55369 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55370 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55371 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55372 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55373 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55374 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55375 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55376 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55377 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55379 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55380 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55381 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55382 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55383 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55384 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55385 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55386 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55387 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55388 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55389 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55390 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55391 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55392 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55393 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55394 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55395 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55396 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55397 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55398 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55399 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55400 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55401 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55402 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55403 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55404 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55405 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55407 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55408 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55409 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55411 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55413 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55414 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55415 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55416 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55417 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55420 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55421 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55422 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55423 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55425 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55426 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55431 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55432 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55433 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55434 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55435 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55437 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55439 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55441 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55442 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55444 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55446 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55448 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55449 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55450 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55451 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55452 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55453 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55454 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55455 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55457 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55458 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55468 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55474 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55475 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55476 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55477 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55478 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55479 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55481 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55482 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55483 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55485 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55486 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55489 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55490 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55491 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55492 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55493 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55494 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55495 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55496 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55498 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55499 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55501 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55502 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55503 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55505 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55506 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55508 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55509 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55510 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55511 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55512 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55513 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55514 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55515 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55516 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55518 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55519 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55521 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55522 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55523 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55524 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55525 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55526 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55527 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55528 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55529 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55530 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55531 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55534 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55535 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55536 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55537 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55538 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55539 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55540 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55541 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55542 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55543 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55544 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55545 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55547 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55548 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55550 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55551 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55552 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55553 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55554 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55555 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55556 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55557 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55559 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55560 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55561 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55562 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55563 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55564 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55565 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55566 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55567 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55569 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55570 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55571 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55575 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55576 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55577 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55578 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55579 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55580 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55582 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55583 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55585 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55586 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55587 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55588 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55589 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55590 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55591 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55592 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55593 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55594 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55595 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55596 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55597 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55598 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55600 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55603 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55604 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55605 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55606 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55607 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55608 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55609 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55612 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55614 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55615 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55616 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55617 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55618 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55619 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55621 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55622 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55624 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55625 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55626 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55627 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55628 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55629 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55630 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55631 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55632 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55633 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55634 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55635 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55636 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55637 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55638 { NULL, NULL, 0, NULL }
55639 };
55640
55641
55642 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55643
55644 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55645 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55646 }
55647 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55648 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55649 }
55650 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55651 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55652 }
55653 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55654 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55655 }
55656 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55657 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55658 }
55659 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55660 return (void *)((wxSizer *) ((wxGridSizer *) x));
55661 }
55662 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55663 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55664 }
55665 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55666 return (void *)((wxSizer *) ((wxPySizer *) x));
55667 }
55668 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55669 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55670 }
55671 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55672 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55673 }
55674 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55675 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55676 }
55677 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55678 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55679 }
55680 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55681 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55682 }
55683 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55684 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55685 }
55686 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55687 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55688 }
55689 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55690 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55691 }
55692 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55693 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55694 }
55695 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55696 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55697 }
55698 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55699 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55700 }
55701 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55702 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55703 }
55704 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55705 return (void *)((wxEvent *) ((wxPyEvent *) x));
55706 }
55707 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55708 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55709 }
55710 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55711 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55712 }
55713 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55714 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55715 }
55716 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55717 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55718 }
55719 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55720 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55721 }
55722 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55723 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55724 }
55725 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55726 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55727 }
55728 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55729 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55730 }
55731 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55732 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55733 }
55734 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55735 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55736 }
55737 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55738 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55739 }
55740 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55741 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55742 }
55743 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55744 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55745 }
55746 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55747 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55748 }
55749 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55750 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55751 }
55752 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55753 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55754 }
55755 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55756 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55757 }
55758 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55759 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55760 }
55761 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55762 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55763 }
55764 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55765 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55766 }
55767 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55768 return (void *)((wxEvent *) ((wxShowEvent *) x));
55769 }
55770 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55771 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55772 }
55773 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55774 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55775 }
55776 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55777 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55778 }
55779 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55780 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55781 }
55782 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55783 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55784 }
55785 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55786 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55787 }
55788 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55789 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55790 }
55791 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55792 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55793 }
55794 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55795 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55796 }
55797 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55798 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55799 }
55800 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55801 return (void *)((wxControl *) ((wxControlWithItems *) x));
55802 }
55803 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55804 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55805 }
55806 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55807 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55808 }
55809 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55810 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55811 }
55812 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55813 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55814 }
55815 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55816 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55817 }
55818 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55819 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55820 }
55821 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55822 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55823 }
55824 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55825 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55826 }
55827 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55828 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55829 }
55830 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55831 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55832 }
55833 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55834 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55835 }
55836 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55837 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55838 }
55839 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55840 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55841 }
55842 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55843 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55844 }
55845 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55846 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55847 }
55848 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55849 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55850 }
55851 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55852 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55853 }
55854 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55855 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55856 }
55857 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55858 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55859 }
55860 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55861 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55862 }
55863 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55864 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55865 }
55866 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55867 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55868 }
55869 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55870 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55871 }
55872 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55873 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55874 }
55875 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55876 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55877 }
55878 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55879 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55880 }
55881 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55882 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55883 }
55884 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55885 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55886 }
55887 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55888 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55889 }
55890 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55891 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55892 }
55893 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55894 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55895 }
55896 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55897 return (void *)((wxObject *) ((wxSizerItem *) x));
55898 }
55899 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55900 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55901 }
55902 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55903 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55904 }
55905 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55906 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55907 }
55908 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55909 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55910 }
55911 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55912 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55913 }
55914 static void *_p_wxSizerTo_p_wxObject(void *x) {
55915 return (void *)((wxObject *) ((wxSizer *) x));
55916 }
55917 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55918 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55919 }
55920 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55921 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55922 }
55923 static void *_p_wxEventTo_p_wxObject(void *x) {
55924 return (void *)((wxObject *) ((wxEvent *) x));
55925 }
55926 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55927 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55928 }
55929 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55930 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55931 }
55932 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55933 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55934 }
55935 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55936 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55937 }
55938 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55939 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55940 }
55941 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55942 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55943 }
55944 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55945 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55946 }
55947 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55948 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55949 }
55950 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55951 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55952 }
55953 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55954 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55955 }
55956 static void *_p_wxControlTo_p_wxObject(void *x) {
55957 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55958 }
55959 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55960 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55961 }
55962 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55963 return (void *)((wxObject *) ((wxFSFile *) x));
55964 }
55965 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55966 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55967 }
55968 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55969 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55970 }
55971 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55972 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55973 }
55974 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55975 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55976 }
55977 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55978 return (void *)((wxObject *) ((wxMenuItem *) x));
55979 }
55980 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55982 }
55983 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55984 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55985 }
55986 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55987 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55988 }
55989 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55990 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55991 }
55992 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55993 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55994 }
55995 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55996 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55997 }
55998 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55999 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56000 }
56001 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56002 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56003 }
56004 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56005 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56006 }
56007 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56008 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56009 }
56010 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56011 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56012 }
56013 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56014 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56015 }
56016 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56017 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56018 }
56019 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56020 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56021 }
56022 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56023 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56024 }
56025 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56026 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56027 }
56028 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56029 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56030 }
56031 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56032 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56033 }
56034 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56035 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56036 }
56037 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56038 return (void *)((wxObject *) ((wxImageHandler *) x));
56039 }
56040 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56041 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56042 }
56043 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56044 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56045 }
56046 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56047 return (void *)((wxObject *) ((wxEvtHandler *) x));
56048 }
56049 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56050 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56051 }
56052 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56053 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56054 }
56055 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56056 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56057 }
56058 static void *_p_wxImageTo_p_wxObject(void *x) {
56059 return (void *)((wxObject *) ((wxImage *) x));
56060 }
56061 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56062 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56063 }
56064 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56065 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56066 }
56067 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56068 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56069 }
56070 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56071 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56072 }
56073 static void *_p_wxWindowTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56075 }
56076 static void *_p_wxMenuTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56078 }
56079 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56081 }
56082 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) ((wxFileSystem *) x));
56084 }
56085 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56087 }
56088 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56090 }
56091 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56093 }
56094 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56096 }
56097 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56099 }
56100 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56102 }
56103 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56105 }
56106 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56108 }
56109 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56111 }
56112 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56114 }
56115 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56117 }
56118 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56120 }
56121 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56123 }
56124 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56126 }
56127 static void *_p_wxControlTo_p_wxWindow(void *x) {
56128 return (void *)((wxWindow *) ((wxControl *) x));
56129 }
56130 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56131 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56132 }
56133 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56134 return (void *)((wxWindow *) ((wxMenuBar *) x));
56135 }
56136 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56137 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56138 }
56139 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56140 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56141 }
56142 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56143 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56144 }
56145 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56146 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56147 }
56148 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56149 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56150 }
56151 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56152 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56153 }
56154 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56155 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56156 }
56157 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56158 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56159 }
56160 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56161 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56162 }
56163 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56164 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56165 }
56166 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56167 return (void *)((wxValidator *) ((wxPyValidator *) x));
56168 }
56169 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56170 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56171 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};
56172 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56173 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56174 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56175 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56176 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56177 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56178 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56179 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56180 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56181 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56182 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56183 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56184 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56185 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56186 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56187 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56188 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56189 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56190 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56191 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56192 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56193 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56194 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56195 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56196 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56197 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56198 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56199 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56200 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56201 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56202 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56203 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56204 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56205 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56206 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56207 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56208 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56209 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56210 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56211 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56212 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56213 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56214 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56215 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56216 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56217 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56218 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56219 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56220 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56221 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56222 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56223 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56224 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56225 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56226 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56227 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56228 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56229 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56230 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56231 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56232 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56233 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56234 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56235 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56236 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56237 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56238 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56239 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56240 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56241 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56242 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56243 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56244 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56245 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56246 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56247 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56248 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56249 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56250 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56251 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56252 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56253 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56254 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56255 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56256 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56257 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56258 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56259 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56260 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56261 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56262 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56263 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56264 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56265 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56266 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56267 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56268 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56269 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56270 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56271 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56272 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56273 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56274 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56275 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56276 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56277 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56278 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56279 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56280 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56281 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56282 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56283 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56284 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56285 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56286 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56287 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56288 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56289 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56290 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56291 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56292 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56293 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56294 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56295 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56296 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56297 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56298 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56299 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56300 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56301
56302 static swig_type_info *swig_type_initial[] = {
56303 &_swigt__p_buffer,
56304 &_swigt__p_char,
56305 &_swigt__p_form_ops_t,
56306 &_swigt__p_int,
56307 &_swigt__p_long,
56308 &_swigt__p_unsigned_char,
56309 &_swigt__p_unsigned_int,
56310 &_swigt__p_unsigned_long,
56311 &_swigt__p_wxANIHandler,
56312 &_swigt__p_wxAcceleratorEntry,
56313 &_swigt__p_wxAcceleratorTable,
56314 &_swigt__p_wxActivateEvent,
56315 &_swigt__p_wxAppTraits,
56316 &_swigt__p_wxArrayString,
56317 &_swigt__p_wxBMPHandler,
56318 &_swigt__p_wxBitmap,
56319 &_swigt__p_wxBoxSizer,
56320 &_swigt__p_wxButton,
56321 &_swigt__p_wxCURHandler,
56322 &_swigt__p_wxCaret,
56323 &_swigt__p_wxChildFocusEvent,
56324 &_swigt__p_wxClipboardTextEvent,
56325 &_swigt__p_wxCloseEvent,
56326 &_swigt__p_wxColour,
56327 &_swigt__p_wxCommandEvent,
56328 &_swigt__p_wxContextMenuEvent,
56329 &_swigt__p_wxControl,
56330 &_swigt__p_wxControlWithItems,
56331 &_swigt__p_wxCursor,
56332 &_swigt__p_wxDC,
56333 &_swigt__p_wxDateEvent,
56334 &_swigt__p_wxDateTime,
56335 &_swigt__p_wxDisplayChangedEvent,
56336 &_swigt__p_wxDropFilesEvent,
56337 &_swigt__p_wxDuplexMode,
56338 &_swigt__p_wxEraseEvent,
56339 &_swigt__p_wxEvent,
56340 &_swigt__p_wxEventLoop,
56341 &_swigt__p_wxEventLoopActivator,
56342 &_swigt__p_wxEvtHandler,
56343 &_swigt__p_wxFSFile,
56344 &_swigt__p_wxFileSystem,
56345 &_swigt__p_wxFileSystemHandler,
56346 &_swigt__p_wxFlexGridSizer,
56347 &_swigt__p_wxFocusEvent,
56348 &_swigt__p_wxFont,
56349 &_swigt__p_wxFrame,
56350 &_swigt__p_wxGBPosition,
56351 &_swigt__p_wxGBSizerItem,
56352 &_swigt__p_wxGBSpan,
56353 &_swigt__p_wxGIFHandler,
56354 &_swigt__p_wxGridBagSizer,
56355 &_swigt__p_wxGridSizer,
56356 &_swigt__p_wxHelpEvent__Origin,
56357 &_swigt__p_wxICOHandler,
56358 &_swigt__p_wxIconizeEvent,
56359 &_swigt__p_wxIdleEvent,
56360 &_swigt__p_wxImage,
56361 &_swigt__p_wxImageHandler,
56362 &_swigt__p_wxImageHistogram,
56363 &_swigt__p_wxImage_HSVValue,
56364 &_swigt__p_wxImage_RGBValue,
56365 &_swigt__p_wxIndividualLayoutConstraint,
56366 &_swigt__p_wxInitDialogEvent,
56367 &_swigt__p_wxInputStream,
56368 &_swigt__p_wxInternetFSHandler,
56369 &_swigt__p_wxItemContainer,
56370 &_swigt__p_wxJPEGHandler,
56371 &_swigt__p_wxKeyEvent,
56372 &_swigt__p_wxLayoutConstraints,
56373 &_swigt__p_wxMaximizeEvent,
56374 &_swigt__p_wxMemoryFSHandler,
56375 &_swigt__p_wxMenu,
56376 &_swigt__p_wxMenuBar,
56377 &_swigt__p_wxMenuBarBase,
56378 &_swigt__p_wxMenuEvent,
56379 &_swigt__p_wxMenuItem,
56380 &_swigt__p_wxMouseCaptureChangedEvent,
56381 &_swigt__p_wxMouseCaptureLostEvent,
56382 &_swigt__p_wxMouseEvent,
56383 &_swigt__p_wxMoveEvent,
56384 &_swigt__p_wxNavigationKeyEvent,
56385 &_swigt__p_wxNcPaintEvent,
56386 &_swigt__p_wxNotifyEvent,
56387 &_swigt__p_wxObject,
56388 &_swigt__p_wxOutputStream,
56389 &_swigt__p_wxPCXHandler,
56390 &_swigt__p_wxPNGHandler,
56391 &_swigt__p_wxPNMHandler,
56392 &_swigt__p_wxPaintEvent,
56393 &_swigt__p_wxPaletteChangedEvent,
56394 &_swigt__p_wxPaperSize,
56395 &_swigt__p_wxPoint,
56396 &_swigt__p_wxPoint2D,
56397 &_swigt__p_wxPropagateOnce,
56398 &_swigt__p_wxPropagationDisabler,
56399 &_swigt__p_wxPyApp,
56400 &_swigt__p_wxPyCommandEvent,
56401 &_swigt__p_wxPyDropTarget,
56402 &_swigt__p_wxPyEvent,
56403 &_swigt__p_wxPyFileSystemHandler,
56404 &_swigt__p_wxPyImageHandler,
56405 &_swigt__p_wxPyInputStream,
56406 &_swigt__p_wxPySizer,
56407 &_swigt__p_wxPyValidator,
56408 &_swigt__p_wxQuantize,
56409 &_swigt__p_wxQueryNewPaletteEvent,
56410 &_swigt__p_wxRealPoint,
56411 &_swigt__p_wxRect,
56412 &_swigt__p_wxRegion,
56413 &_swigt__p_wxScrollEvent,
56414 &_swigt__p_wxScrollWinEvent,
56415 &_swigt__p_wxSetCursorEvent,
56416 &_swigt__p_wxShowEvent,
56417 &_swigt__p_wxSize,
56418 &_swigt__p_wxSizeEvent,
56419 &_swigt__p_wxSizer,
56420 &_swigt__p_wxSizerItem,
56421 &_swigt__p_wxStaticBox,
56422 &_swigt__p_wxStaticBoxSizer,
56423 &_swigt__p_wxStdDialogButtonSizer,
56424 &_swigt__p_wxSysColourChangedEvent,
56425 &_swigt__p_wxTIFFHandler,
56426 &_swigt__p_wxToolTip,
56427 &_swigt__p_wxUpdateUIEvent,
56428 &_swigt__p_wxValidator,
56429 &_swigt__p_wxVisualAttributes,
56430 &_swigt__p_wxWindow,
56431 &_swigt__p_wxWindowCreateEvent,
56432 &_swigt__p_wxWindowDestroyEvent,
56433 &_swigt__p_wxXPMHandler,
56434 &_swigt__p_wxZipFSHandler,
56435 };
56436
56437 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56438 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56439 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56440 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56441 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56442 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56443 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56444 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56445 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56446 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56447 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56448 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56449 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56450 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56451 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}};
56452 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56453 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}};
56454 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56455 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}};
56456 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56457 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56458 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56459 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56460 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56461 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}};
56462 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56463 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}};
56464 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56465 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56466 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56467 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56468 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56469 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56470 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56471 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56472 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56473 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}};
56474 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56475 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56476 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}};
56477 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56478 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56479 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}};
56480 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}};
56481 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56482 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56483 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56484 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56485 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56486 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56487 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56488 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56489 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}};
56490 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56491 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}};
56492 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56493 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56494 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56495 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}};
56496 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56497 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56498 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56499 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56500 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56501 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56502 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56503 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}};
56504 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56505 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56506 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56507 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56508 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56509 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56510 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56511 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56512 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56513 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56514 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56515 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56516 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56517 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56518 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56519 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56520 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56521 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}};
56522 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56523 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56524 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56525 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56526 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56527 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56528 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56529 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56530 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56531 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56532 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56533 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56534 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56535 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56536 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56537 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56538 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56539 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56540 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56541 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56542 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56543 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56544 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56545 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56546 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56547 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56548 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56549 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56550 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56551 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56552 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56553 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}};
56554 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}};
56555 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56556 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56557 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56558 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56559 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56560 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56561 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56562 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}};
56563 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56564 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}};
56565 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56566 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56567 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56568 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56569
56570 static swig_cast_info *swig_cast_initial[] = {
56571 _swigc__p_buffer,
56572 _swigc__p_char,
56573 _swigc__p_form_ops_t,
56574 _swigc__p_int,
56575 _swigc__p_long,
56576 _swigc__p_unsigned_char,
56577 _swigc__p_unsigned_int,
56578 _swigc__p_unsigned_long,
56579 _swigc__p_wxANIHandler,
56580 _swigc__p_wxAcceleratorEntry,
56581 _swigc__p_wxAcceleratorTable,
56582 _swigc__p_wxActivateEvent,
56583 _swigc__p_wxAppTraits,
56584 _swigc__p_wxArrayString,
56585 _swigc__p_wxBMPHandler,
56586 _swigc__p_wxBitmap,
56587 _swigc__p_wxBoxSizer,
56588 _swigc__p_wxButton,
56589 _swigc__p_wxCURHandler,
56590 _swigc__p_wxCaret,
56591 _swigc__p_wxChildFocusEvent,
56592 _swigc__p_wxClipboardTextEvent,
56593 _swigc__p_wxCloseEvent,
56594 _swigc__p_wxColour,
56595 _swigc__p_wxCommandEvent,
56596 _swigc__p_wxContextMenuEvent,
56597 _swigc__p_wxControl,
56598 _swigc__p_wxControlWithItems,
56599 _swigc__p_wxCursor,
56600 _swigc__p_wxDC,
56601 _swigc__p_wxDateEvent,
56602 _swigc__p_wxDateTime,
56603 _swigc__p_wxDisplayChangedEvent,
56604 _swigc__p_wxDropFilesEvent,
56605 _swigc__p_wxDuplexMode,
56606 _swigc__p_wxEraseEvent,
56607 _swigc__p_wxEvent,
56608 _swigc__p_wxEventLoop,
56609 _swigc__p_wxEventLoopActivator,
56610 _swigc__p_wxEvtHandler,
56611 _swigc__p_wxFSFile,
56612 _swigc__p_wxFileSystem,
56613 _swigc__p_wxFileSystemHandler,
56614 _swigc__p_wxFlexGridSizer,
56615 _swigc__p_wxFocusEvent,
56616 _swigc__p_wxFont,
56617 _swigc__p_wxFrame,
56618 _swigc__p_wxGBPosition,
56619 _swigc__p_wxGBSizerItem,
56620 _swigc__p_wxGBSpan,
56621 _swigc__p_wxGIFHandler,
56622 _swigc__p_wxGridBagSizer,
56623 _swigc__p_wxGridSizer,
56624 _swigc__p_wxHelpEvent__Origin,
56625 _swigc__p_wxICOHandler,
56626 _swigc__p_wxIconizeEvent,
56627 _swigc__p_wxIdleEvent,
56628 _swigc__p_wxImage,
56629 _swigc__p_wxImageHandler,
56630 _swigc__p_wxImageHistogram,
56631 _swigc__p_wxImage_HSVValue,
56632 _swigc__p_wxImage_RGBValue,
56633 _swigc__p_wxIndividualLayoutConstraint,
56634 _swigc__p_wxInitDialogEvent,
56635 _swigc__p_wxInputStream,
56636 _swigc__p_wxInternetFSHandler,
56637 _swigc__p_wxItemContainer,
56638 _swigc__p_wxJPEGHandler,
56639 _swigc__p_wxKeyEvent,
56640 _swigc__p_wxLayoutConstraints,
56641 _swigc__p_wxMaximizeEvent,
56642 _swigc__p_wxMemoryFSHandler,
56643 _swigc__p_wxMenu,
56644 _swigc__p_wxMenuBar,
56645 _swigc__p_wxMenuBarBase,
56646 _swigc__p_wxMenuEvent,
56647 _swigc__p_wxMenuItem,
56648 _swigc__p_wxMouseCaptureChangedEvent,
56649 _swigc__p_wxMouseCaptureLostEvent,
56650 _swigc__p_wxMouseEvent,
56651 _swigc__p_wxMoveEvent,
56652 _swigc__p_wxNavigationKeyEvent,
56653 _swigc__p_wxNcPaintEvent,
56654 _swigc__p_wxNotifyEvent,
56655 _swigc__p_wxObject,
56656 _swigc__p_wxOutputStream,
56657 _swigc__p_wxPCXHandler,
56658 _swigc__p_wxPNGHandler,
56659 _swigc__p_wxPNMHandler,
56660 _swigc__p_wxPaintEvent,
56661 _swigc__p_wxPaletteChangedEvent,
56662 _swigc__p_wxPaperSize,
56663 _swigc__p_wxPoint,
56664 _swigc__p_wxPoint2D,
56665 _swigc__p_wxPropagateOnce,
56666 _swigc__p_wxPropagationDisabler,
56667 _swigc__p_wxPyApp,
56668 _swigc__p_wxPyCommandEvent,
56669 _swigc__p_wxPyDropTarget,
56670 _swigc__p_wxPyEvent,
56671 _swigc__p_wxPyFileSystemHandler,
56672 _swigc__p_wxPyImageHandler,
56673 _swigc__p_wxPyInputStream,
56674 _swigc__p_wxPySizer,
56675 _swigc__p_wxPyValidator,
56676 _swigc__p_wxQuantize,
56677 _swigc__p_wxQueryNewPaletteEvent,
56678 _swigc__p_wxRealPoint,
56679 _swigc__p_wxRect,
56680 _swigc__p_wxRegion,
56681 _swigc__p_wxScrollEvent,
56682 _swigc__p_wxScrollWinEvent,
56683 _swigc__p_wxSetCursorEvent,
56684 _swigc__p_wxShowEvent,
56685 _swigc__p_wxSize,
56686 _swigc__p_wxSizeEvent,
56687 _swigc__p_wxSizer,
56688 _swigc__p_wxSizerItem,
56689 _swigc__p_wxStaticBox,
56690 _swigc__p_wxStaticBoxSizer,
56691 _swigc__p_wxStdDialogButtonSizer,
56692 _swigc__p_wxSysColourChangedEvent,
56693 _swigc__p_wxTIFFHandler,
56694 _swigc__p_wxToolTip,
56695 _swigc__p_wxUpdateUIEvent,
56696 _swigc__p_wxValidator,
56697 _swigc__p_wxVisualAttributes,
56698 _swigc__p_wxWindow,
56699 _swigc__p_wxWindowCreateEvent,
56700 _swigc__p_wxWindowDestroyEvent,
56701 _swigc__p_wxXPMHandler,
56702 _swigc__p_wxZipFSHandler,
56703 };
56704
56705
56706 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56707
56708 static swig_const_info swig_const_table[] = {
56709 {0, 0, 0, 0.0, 0, 0}};
56710
56711 #ifdef __cplusplus
56712 }
56713 #endif
56714 /* -----------------------------------------------------------------------------
56715 * Type initialization:
56716 * This problem is tough by the requirement that no dynamic
56717 * memory is used. Also, since swig_type_info structures store pointers to
56718 * swig_cast_info structures and swig_cast_info structures store pointers back
56719 * to swig_type_info structures, we need some lookup code at initialization.
56720 * The idea is that swig generates all the structures that are needed.
56721 * The runtime then collects these partially filled structures.
56722 * The SWIG_InitializeModule function takes these initial arrays out of
56723 * swig_module, and does all the lookup, filling in the swig_module.types
56724 * array with the correct data and linking the correct swig_cast_info
56725 * structures together.
56726 *
56727 * The generated swig_type_info structures are assigned staticly to an initial
56728 * array. We just loop though that array, and handle each type individually.
56729 * First we lookup if this type has been already loaded, and if so, use the
56730 * loaded structure instead of the generated one. Then we have to fill in the
56731 * cast linked list. The cast data is initially stored in something like a
56732 * two-dimensional array. Each row corresponds to a type (there are the same
56733 * number of rows as there are in the swig_type_initial array). Each entry in
56734 * a column is one of the swig_cast_info structures for that type.
56735 * The cast_initial array is actually an array of arrays, because each row has
56736 * a variable number of columns. So to actually build the cast linked list,
56737 * we find the array of casts associated with the type, and loop through it
56738 * adding the casts to the list. The one last trick we need to do is making
56739 * sure the type pointer in the swig_cast_info struct is correct.
56740 *
56741 * First off, we lookup the cast->type name to see if it is already loaded.
56742 * There are three cases to handle:
56743 * 1) If the cast->type has already been loaded AND the type we are adding
56744 * casting info to has not been loaded (it is in this module), THEN we
56745 * replace the cast->type pointer with the type pointer that has already
56746 * been loaded.
56747 * 2) If BOTH types (the one we are adding casting info to, and the
56748 * cast->type) are loaded, THEN the cast info has already been loaded by
56749 * the previous module so we just ignore it.
56750 * 3) Finally, if cast->type has not already been loaded, then we add that
56751 * swig_cast_info to the linked list (because the cast->type) pointer will
56752 * be correct.
56753 * ----------------------------------------------------------------------------- */
56754
56755 #ifdef __cplusplus
56756 extern "C" {
56757 #if 0
56758 } /* c-mode */
56759 #endif
56760 #endif
56761
56762 #if 0
56763 #define SWIGRUNTIME_DEBUG
56764 #endif
56765
56766 SWIGRUNTIME void
56767 SWIG_InitializeModule(void *clientdata) {
56768 size_t i;
56769 swig_module_info *module_head;
56770 static int init_run = 0;
56771
56772 clientdata = clientdata;
56773
56774 if (init_run) return;
56775 init_run = 1;
56776
56777 /* Initialize the swig_module */
56778 swig_module.type_initial = swig_type_initial;
56779 swig_module.cast_initial = swig_cast_initial;
56780
56781 /* Try and load any already created modules */
56782 module_head = SWIG_GetModule(clientdata);
56783 if (module_head) {
56784 swig_module.next = module_head->next;
56785 module_head->next = &swig_module;
56786 } else {
56787 /* This is the first module loaded */
56788 swig_module.next = &swig_module;
56789 SWIG_SetModule(clientdata, &swig_module);
56790 }
56791
56792 /* Now work on filling in swig_module.types */
56793 #ifdef SWIGRUNTIME_DEBUG
56794 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56795 #endif
56796 for (i = 0; i < swig_module.size; ++i) {
56797 swig_type_info *type = 0;
56798 swig_type_info *ret;
56799 swig_cast_info *cast;
56800
56801 #ifdef SWIGRUNTIME_DEBUG
56802 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56803 #endif
56804
56805 /* if there is another module already loaded */
56806 if (swig_module.next != &swig_module) {
56807 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56808 }
56809 if (type) {
56810 /* Overwrite clientdata field */
56811 #ifdef SWIGRUNTIME_DEBUG
56812 printf("SWIG_InitializeModule: found type %s\n", type->name);
56813 #endif
56814 if (swig_module.type_initial[i]->clientdata) {
56815 type->clientdata = swig_module.type_initial[i]->clientdata;
56816 #ifdef SWIGRUNTIME_DEBUG
56817 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56818 #endif
56819 }
56820 } else {
56821 type = swig_module.type_initial[i];
56822 }
56823
56824 /* Insert casting types */
56825 cast = swig_module.cast_initial[i];
56826 while (cast->type) {
56827 /* Don't need to add information already in the list */
56828 ret = 0;
56829 #ifdef SWIGRUNTIME_DEBUG
56830 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56831 #endif
56832 if (swig_module.next != &swig_module) {
56833 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56834 #ifdef SWIGRUNTIME_DEBUG
56835 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56836 #endif
56837 }
56838 if (ret) {
56839 if (type == swig_module.type_initial[i]) {
56840 #ifdef SWIGRUNTIME_DEBUG
56841 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56842 #endif
56843 cast->type = ret;
56844 ret = 0;
56845 } else {
56846 /* Check for casting already in the list */
56847 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56848 #ifdef SWIGRUNTIME_DEBUG
56849 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56850 #endif
56851 if (!ocast) ret = 0;
56852 }
56853 }
56854
56855 if (!ret) {
56856 #ifdef SWIGRUNTIME_DEBUG
56857 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56858 #endif
56859 if (type->cast) {
56860 type->cast->prev = cast;
56861 cast->next = type->cast;
56862 }
56863 type->cast = cast;
56864 }
56865 cast++;
56866 }
56867 /* Set entry in modules->types array equal to the type */
56868 swig_module.types[i] = type;
56869 }
56870 swig_module.types[i] = 0;
56871
56872 #ifdef SWIGRUNTIME_DEBUG
56873 printf("**** SWIG_InitializeModule: Cast List ******\n");
56874 for (i = 0; i < swig_module.size; ++i) {
56875 int j = 0;
56876 swig_cast_info *cast = swig_module.cast_initial[i];
56877 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56878 while (cast->type) {
56879 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56880 cast++;
56881 ++j;
56882 }
56883 printf("---- Total casts: %d\n",j);
56884 }
56885 printf("**** SWIG_InitializeModule: Cast List ******\n");
56886 #endif
56887 }
56888
56889 /* This function will propagate the clientdata field of type to
56890 * any new swig_type_info structures that have been added into the list
56891 * of equivalent types. It is like calling
56892 * SWIG_TypeClientData(type, clientdata) a second time.
56893 */
56894 SWIGRUNTIME void
56895 SWIG_PropagateClientData(void) {
56896 size_t i;
56897 swig_cast_info *equiv;
56898 static int init_run = 0;
56899
56900 if (init_run) return;
56901 init_run = 1;
56902
56903 for (i = 0; i < swig_module.size; i++) {
56904 if (swig_module.types[i]->clientdata) {
56905 equiv = swig_module.types[i]->cast;
56906 while (equiv) {
56907 if (!equiv->converter) {
56908 if (equiv->type && !equiv->type->clientdata)
56909 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56910 }
56911 equiv = equiv->next;
56912 }
56913 }
56914 }
56915 }
56916
56917 #ifdef __cplusplus
56918 #if 0
56919 {
56920 /* c-mode */
56921 #endif
56922 }
56923 #endif
56924
56925
56926
56927 #ifdef __cplusplus
56928 extern "C" {
56929 #endif
56930
56931 /* Python-specific SWIG API */
56932 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56933 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56934 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56935
56936 /* -----------------------------------------------------------------------------
56937 * global variable support code.
56938 * ----------------------------------------------------------------------------- */
56939
56940 typedef struct swig_globalvar {
56941 char *name; /* Name of global variable */
56942 PyObject *(*get_attr)(void); /* Return the current value */
56943 int (*set_attr)(PyObject *); /* Set the value */
56944 struct swig_globalvar *next;
56945 } swig_globalvar;
56946
56947 typedef struct swig_varlinkobject {
56948 PyObject_HEAD
56949 swig_globalvar *vars;
56950 } swig_varlinkobject;
56951
56952 SWIGINTERN PyObject *
56953 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56954 return PyString_FromString("<Swig global variables>");
56955 }
56956
56957 SWIGINTERN PyObject *
56958 swig_varlink_str(swig_varlinkobject *v) {
56959 PyObject *str = PyString_FromString("(");
56960 swig_globalvar *var;
56961 for (var = v->vars; var; var=var->next) {
56962 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56963 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56964 }
56965 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56966 return str;
56967 }
56968
56969 SWIGINTERN int
56970 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56971 PyObject *str = swig_varlink_str(v);
56972 fprintf(fp,"Swig global variables ");
56973 fprintf(fp,"%s\n", PyString_AsString(str));
56974 Py_DECREF(str);
56975 return 0;
56976 }
56977
56978 SWIGINTERN void
56979 swig_varlink_dealloc(swig_varlinkobject *v) {
56980 swig_globalvar *var = v->vars;
56981 while (var) {
56982 swig_globalvar *n = var->next;
56983 free(var->name);
56984 free(var);
56985 var = n;
56986 }
56987 }
56988
56989 SWIGINTERN PyObject *
56990 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56991 PyObject *res = NULL;
56992 swig_globalvar *var = v->vars;
56993 while (var) {
56994 if (strcmp(var->name,n) == 0) {
56995 res = (*var->get_attr)();
56996 break;
56997 }
56998 var = var->next;
56999 }
57000 if (res == NULL && !PyErr_Occurred()) {
57001 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57002 }
57003 return res;
57004 }
57005
57006 SWIGINTERN int
57007 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57008 int res = 1;
57009 swig_globalvar *var = v->vars;
57010 while (var) {
57011 if (strcmp(var->name,n) == 0) {
57012 res = (*var->set_attr)(p);
57013 break;
57014 }
57015 var = var->next;
57016 }
57017 if (res == 1 && !PyErr_Occurred()) {
57018 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57019 }
57020 return res;
57021 }
57022
57023 SWIGINTERN PyTypeObject*
57024 swig_varlink_type(void) {
57025 static char varlink__doc__[] = "Swig var link object";
57026 static PyTypeObject varlink_type;
57027 static int type_init = 0;
57028 if (!type_init) {
57029 const PyTypeObject tmp
57030 = {
57031 PyObject_HEAD_INIT(NULL)
57032 0, /* Number of items in variable part (ob_size) */
57033 (char *)"swigvarlink", /* Type name (tp_name) */
57034 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57035 0, /* Itemsize (tp_itemsize) */
57036 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57037 (printfunc) swig_varlink_print, /* Print (tp_print) */
57038 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57039 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57040 0, /* tp_compare */
57041 (reprfunc) swig_varlink_repr, /* tp_repr */
57042 0, /* tp_as_number */
57043 0, /* tp_as_sequence */
57044 0, /* tp_as_mapping */
57045 0, /* tp_hash */
57046 0, /* tp_call */
57047 (reprfunc)swig_varlink_str, /* tp_str */
57048 0, /* tp_getattro */
57049 0, /* tp_setattro */
57050 0, /* tp_as_buffer */
57051 0, /* tp_flags */
57052 varlink__doc__, /* tp_doc */
57053 0, /* tp_traverse */
57054 0, /* tp_clear */
57055 0, /* tp_richcompare */
57056 0, /* tp_weaklistoffset */
57057 #if PY_VERSION_HEX >= 0x02020000
57058 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57059 #endif
57060 #if PY_VERSION_HEX >= 0x02030000
57061 0, /* tp_del */
57062 #endif
57063 #ifdef COUNT_ALLOCS
57064 0,0,0,0 /* tp_alloc -> tp_next */
57065 #endif
57066 };
57067 varlink_type = tmp;
57068 varlink_type.ob_type = &PyType_Type;
57069 type_init = 1;
57070 }
57071 return &varlink_type;
57072 }
57073
57074 /* Create a variable linking object for use later */
57075 SWIGINTERN PyObject *
57076 SWIG_Python_newvarlink(void) {
57077 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57078 if (result) {
57079 result->vars = 0;
57080 }
57081 return ((PyObject*) result);
57082 }
57083
57084 SWIGINTERN void
57085 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57086 swig_varlinkobject *v = (swig_varlinkobject *) p;
57087 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57088 if (gv) {
57089 size_t size = strlen(name)+1;
57090 gv->name = (char *)malloc(size);
57091 if (gv->name) {
57092 strncpy(gv->name,name,size);
57093 gv->get_attr = get_attr;
57094 gv->set_attr = set_attr;
57095 gv->next = v->vars;
57096 }
57097 }
57098 v->vars = gv;
57099 }
57100
57101 SWIGINTERN PyObject *
57102 SWIG_globals() {
57103 static PyObject *_SWIG_globals = 0;
57104 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57105 return _SWIG_globals;
57106 }
57107
57108 /* -----------------------------------------------------------------------------
57109 * constants/methods manipulation
57110 * ----------------------------------------------------------------------------- */
57111
57112 /* Install Constants */
57113 SWIGINTERN void
57114 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57115 PyObject *obj = 0;
57116 size_t i;
57117 for (i = 0; constants[i].type; ++i) {
57118 switch(constants[i].type) {
57119 case SWIG_PY_POINTER:
57120 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57121 break;
57122 case SWIG_PY_BINARY:
57123 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57124 break;
57125 default:
57126 obj = 0;
57127 break;
57128 }
57129 if (obj) {
57130 PyDict_SetItemString(d, constants[i].name, obj);
57131 Py_DECREF(obj);
57132 }
57133 }
57134 }
57135
57136 /* -----------------------------------------------------------------------------*/
57137 /* Fix SwigMethods to carry the callback ptrs when needed */
57138 /* -----------------------------------------------------------------------------*/
57139
57140 SWIGINTERN void
57141 SWIG_Python_FixMethods(PyMethodDef *methods,
57142 swig_const_info *const_table,
57143 swig_type_info **types,
57144 swig_type_info **types_initial) {
57145 size_t i;
57146 for (i = 0; methods[i].ml_name; ++i) {
57147 const char *c = methods[i].ml_doc;
57148 if (c && (c = strstr(c, "swig_ptr: "))) {
57149 int j;
57150 swig_const_info *ci = 0;
57151 const char *name = c + 10;
57152 for (j = 0; const_table[j].type; ++j) {
57153 if (strncmp(const_table[j].name, name,
57154 strlen(const_table[j].name)) == 0) {
57155 ci = &(const_table[j]);
57156 break;
57157 }
57158 }
57159 if (ci) {
57160 size_t shift = (ci->ptype) - types;
57161 swig_type_info *ty = types_initial[shift];
57162 size_t ldoc = (c - methods[i].ml_doc);
57163 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57164 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57165 if (ndoc) {
57166 char *buff = ndoc;
57167 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57168 if (ptr) {
57169 strncpy(buff, methods[i].ml_doc, ldoc);
57170 buff += ldoc;
57171 strncpy(buff, "swig_ptr: ", 10);
57172 buff += 10;
57173 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57174 methods[i].ml_doc = ndoc;
57175 }
57176 }
57177 }
57178 }
57179 }
57180 }
57181
57182 #ifdef __cplusplus
57183 }
57184 #endif
57185
57186 /* -----------------------------------------------------------------------------*
57187 * Partial Init method
57188 * -----------------------------------------------------------------------------*/
57189
57190 #ifdef __cplusplus
57191 extern "C"
57192 #endif
57193 SWIGEXPORT void SWIG_init(void) {
57194 PyObject *m, *d;
57195
57196 /* Fix SwigMethods to carry the callback ptrs when needed */
57197 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57198
57199 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57200 d = PyModule_GetDict(m);
57201
57202 SWIG_InitializeModule(0);
57203 SWIG_InstallConstants(d,swig_const_table);
57204
57205
57206
57207 #ifndef wxPyUSE_EXPORT
57208 // Make our API structure a CObject so other modules can import it
57209 // from this module.
57210 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57211 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57212 Py_XDECREF(cobj);
57213 #endif
57214
57215 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57216 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57217 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57218 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57219 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57220 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57221 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57222 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57223 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57224 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57225 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57226 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57227 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57228 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57229 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57230 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57231 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57232 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57233 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57234 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57235 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57236 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57237 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57238 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57239 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57240 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57241 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57242 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57243 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57244 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57245 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57246 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57247 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57248 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57249 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57250 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57251 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57252 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57253 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57254 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57255 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57256 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57257 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57258 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57259 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57260 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57261 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57262 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57263 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57264 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57265 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57266 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57267 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57268 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57269 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57270 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57271 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57272 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57273 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57274 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57275 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57276 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57277 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57278 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57279 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57280 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57281 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57282 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57283 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57284 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57285 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57286 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57287 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57288 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57289 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57290 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57291 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57292 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57293 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57294 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57295 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57296 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57297 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57298 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57299 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57300 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57301 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57302 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57303 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57304 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57305 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57306 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57307 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57308 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57309 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57310 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57311 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57312 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57313 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57314 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57315 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57316 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57317 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57318 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57319 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57320 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57321 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57322 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57323 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57324 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57325 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57326 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57327 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57328 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57329 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57330 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57331 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57332 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57333 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57334 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57335 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57336 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57337 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57338 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57339 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57340 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57341 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57342 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57343 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57344 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57345 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57346 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57347 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57348 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57349 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57350 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57351 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57352 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57353 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57354 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57355 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57356 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57357 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57358 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57359 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57360 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57361 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57362 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57363 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57364 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57365 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57366 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57367 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57368 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57369 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57370 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57371 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57372 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57373 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57374 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57375 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57376 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57377 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57378 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57379 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57380 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57381 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57382 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57383 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57384 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57385 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57386 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57387 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57388 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57389 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57390 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57391 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57392 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57393 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57394 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57395 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57396 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57397 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57398 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57399 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57400 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57401 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57402 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57403 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57404 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57405 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57406 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57407 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57408 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57409 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57410 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57411 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57412 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57413 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57414 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57415 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57416 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57417 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57418 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57419 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57420 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57421 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57422 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57423 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57424 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57425 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57426 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57427 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57428 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57429 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57430 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57431 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57432 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57433 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57434 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57435 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57436 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57437 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57438 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57439 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57440 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57441 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57442 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57443 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57444 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57445 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57446 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57447 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57448 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57449 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57450 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57451 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57452 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57453 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57454 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57455 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57456 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57457 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57458 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57459 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57460 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57461 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57462 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57463 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57464 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57465 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57466 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57467 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57468 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57469 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57470 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57471 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57472 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57473 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57474 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57475 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57476 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57477 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57478 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57479 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57480 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57481 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57482 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57483 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57484 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57485 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57486 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57487 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57488 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57489 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57490 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57491 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57492 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57493 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57494 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57495 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57496 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57497 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57498 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57499 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57500 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57501 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57502 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57503 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57504 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57505 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57506 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57507 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57508 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57509 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57510 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57511 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57512 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57513 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57514 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57515 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57516 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57517 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57518 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57519 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57520 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57521 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57522 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57523 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57524 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57525 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57526 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57527 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57528 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57529 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57530 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57531 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57532 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57533 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57534 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57535 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57536 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57537 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57538 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57539 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57540 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57541 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57542 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57543 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57544 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57545 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57546 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57547 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57548 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57549 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57550 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57551 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57552 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57553 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57554 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57555 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57556 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57557 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57558 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57559 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57560 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57561 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57562 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57563 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57564 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57565 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57566 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57567 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57568 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57569 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57570 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57571 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57572 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57573 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57574 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57575 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57576 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57577 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57578 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57579 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57580 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57581 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57582 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57583 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57584 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57585 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57586 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57587 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57588 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57589 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57590 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57591 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57592 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57593 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57594 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57595 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57596 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57597 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57598 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57599 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57600 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57601 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57602 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57603 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57604 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57605 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57606 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57607 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57608 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57609 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57610 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57611 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57612 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57613 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57614 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57615 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57616 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57617 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57618 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57619 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57620 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57621 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57622 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57623 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57624 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57625 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57626 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57627 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57628 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57629 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57630 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57631 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57632 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57633 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57634 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57635 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57636 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57637 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57638 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57639 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57640 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57641 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57642 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57643 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57644 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57645 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57646 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57647 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57648 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57649 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57650 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57651 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57652 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57653 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57654 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57655 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57656 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57657 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57658 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57659 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57660 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57661 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57662 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57663 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57664 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57665 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57666 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57667 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57668 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57669 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57670 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57671 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57672 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57673 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57674 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57675 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57676 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57677 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57678 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57679 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57680 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57681 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57682 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57683 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57684 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57685 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57686 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57687 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57688 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57689 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57690 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57691 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57692 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57693 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57694 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57695 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57696 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57697 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57698 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57699 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57700 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57701 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57702 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57703 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57704 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57705 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57706 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57707 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57708 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57709 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57710 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57711 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57712 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57713 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57714 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57715 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57716 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57717 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57718 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57719 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57720 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57721 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57722 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57723 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57724 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57725 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57726 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57727 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57728 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57729 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57730 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57731 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57732 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57733 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57734 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57735 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57736 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57737 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57738 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57739 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57740 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57741 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57742 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57743 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57744 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57745 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57746 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57747 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57748 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57749 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57750 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57751 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57752 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57753 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57754 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57755 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57756 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57757 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57758 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57759 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57760 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57761 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57762 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57763 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57764 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57765 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57766 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57767 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57768 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57769 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57770 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57771 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57772 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57773 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57774 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57775 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57776 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57777 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57778 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57779 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57780 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57781 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57782 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57783 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57784 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57785 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57786 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57787 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57788 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57789 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57790 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57791 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57792 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57793 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57794 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57795 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57796 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57797 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57798 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57799 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57800 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57801 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57802 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57803 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57804 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57805 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57806 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57807 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57808 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57809 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57810 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57811 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57812 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57813 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57814 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57815 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57816 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57817 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57818 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57819 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57820 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57821 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57822 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57823 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57824 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57825 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57826 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57827 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57828 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57829 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57830 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57831 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57832 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57833 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57834 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57835 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57836 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57837 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57838 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57839 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57840 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57841 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57842 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57843 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57844 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57845 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57846 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57847 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57848 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57849 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57850 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57851 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57852 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57853 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57854 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57855 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57856 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57857 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57858 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57859 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57860 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57861 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57862 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57863 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57864 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57865 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57866 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57867 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57868 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57869 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57870 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57871 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57872 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57873 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57874
57875 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57876
57877
57878 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57879
57880 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57881 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57882 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57883 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
57884 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
57885 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57886 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57887 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57888 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57889 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57890 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57891 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57892 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57893 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57894 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57895 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57896 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57897 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57898 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57899 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57900 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57901 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57902 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57903 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57904 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57905 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57906 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57907 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57908 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57909 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57910 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57911 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57912 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57913 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57914 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57915 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57916 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57917 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57918 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57919 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57920 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57921 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57922 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57923 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57924 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57925 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57926 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57927 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57928 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57929 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57930 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57931 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57932 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57933 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57934 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57935 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57936 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57937 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57938 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57939 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57940 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57941 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57942 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57943 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57944 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57945 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57946 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57947 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57948 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57949 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57950 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57951 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57952 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57953 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57954 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57955 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57956 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57957 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57958 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57959 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57960 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57961 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57962 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57963 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57964 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57965 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57966 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57967 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57968 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57969 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57970 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57971 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57972 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57973 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57974 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57975 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57976 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57977 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57978 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57979 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57980 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57981 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57982 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57983 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57984 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57985 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57986 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57987 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57988 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57989 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57990 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57991 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57992 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57993 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57994 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57995 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57996 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57997 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57998 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57999 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58000 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58001 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58002 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58003 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58004 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58005 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58006 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58007 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58008 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58009 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58010 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58011 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58012 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58013 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58014 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58015 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58016 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58017 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58018 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58019 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58020 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58021 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58022 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58023 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58024 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58025 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58026 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58027 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58028 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58029 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58030 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58031 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58032 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58033 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58034 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58035 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58036 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58037 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58038 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58039 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58040 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58041 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58042 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58043 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58044 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58045 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58046 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58047 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58048 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58049 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58050 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58051 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58052 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58053 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58054 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58055 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58056 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58057 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58058 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58059 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58060 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58061 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58062 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58063 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58064 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58065 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58066 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58067 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58068 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58069 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58070 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58071 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58072 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58073 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58074 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58075 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58076 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58077 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58078 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58079 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58080 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58081 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58082 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58083 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58084 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58085 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58086 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58087 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58088 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58089 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58090 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58091 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58092 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58093 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58094
58095 // Initialize threading, some globals and such
58096 __wxPyPreStart(d);
58097
58098
58099 // Although these are defined in __version__ they need to be here too so
58100 // that an assert can be done to ensure that the wxPython and the wxWindows
58101 // versions match.
58102 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58103 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58104 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58105
58106 }
58107
wxWidgets (Impactor)