]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


4926571a021a25f20f37af6180009c4602d4bb96
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3792 return wxPyTestDisplayAvailable();
3793 }
3794
3795 void wxApp_CleanUp() {
3796 __wxPyCleanup();
3797 }
3798
3799
3800 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3801
3802
3803
3804
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_FromCharPtr(const char *cptr)
3808 {
3809 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3810 }
3811
3812
3813 #if 0 // #ifdef __WXMAC__
3814
3815 // A dummy class that raises an exception if used...
3816 class wxEventLoop
3817 {
3818 public:
3819 wxEventLoop() { wxPyRaiseNotImplemented(); }
3820 int Run() { return 0; }
3821 void Exit(int rc = 0) {}
3822 bool Pending() const { return false; }
3823 bool Dispatch() { return false; }
3824 bool IsRunning() const { return false; }
3825 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3826 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3827 };
3828
3829 #else
3830
3831 #include <wx/evtloop.h>
3832
3833 #endif
3834
3835
3836
3837 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3838 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3839 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3840 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3841 wxWindowList& list = self->GetChildren();
3842 return wxPy_ConvertList(&list);
3843 }
3844 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
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 wxMenuBar_SetAutoWindowMenu(bool enable){}
3934 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3935 static const wxString wxPyControlNameStr(wxControlNameStr);
3936 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3937 if (clientData) {
3938 wxPyClientData* data = new wxPyClientData(clientData);
3939 return self->Append(item, data);
3940 } else
3941 return self->Append(item);
3942 }
3943 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3944 if (clientData) {
3945 wxPyClientData* data = new wxPyClientData(clientData);
3946 return self->Insert(item, pos, data);
3947 } else
3948 return self->Insert(item, pos);
3949 }
3950 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3951 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3952 if (data) {
3953 Py_INCREF(data->m_obj);
3954 return data->m_obj;
3955 } else {
3956 Py_INCREF(Py_None);
3957 return Py_None;
3958 }
3959 }
3960 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3961 wxPyClientData* data = new wxPyClientData(clientData);
3962 self->SetClientObject(n, data);
3963 }
3964
3965
3966 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3967 wxPyUserData* data = NULL;
3968 if ( userData ) {
3969 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3970 data = new wxPyUserData(userData);
3971 wxPyEndBlockThreads(blocked);
3972 }
3973 return new wxSizerItem(window, proportion, flag, border, data);
3974 }
3975 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3976 wxPyUserData* data = NULL;
3977 if ( userData ) {
3978 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3979 data = new wxPyUserData(userData);
3980 wxPyEndBlockThreads(blocked);
3981 }
3982 return new wxSizerItem(width, height, proportion, flag, border, data);
3983 }
3984 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3985 wxPyUserData* data = NULL;
3986 if ( userData ) {
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 data = new wxPyUserData(userData);
3989 wxPyEndBlockThreads(blocked);
3990 }
3991 return new wxSizerItem(sizer, proportion, flag, border, data);
3992 }
3993
3994 SWIGINTERNINLINE PyObject *
3995 SWIG_From_float (float value)
3996 {
3997 return SWIG_From_double (value);
3998 }
3999
4000 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4001 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4002 if (data) {
4003 Py_INCREF(data->m_obj);
4004 return data->m_obj;
4005 } else {
4006 Py_INCREF(Py_None);
4007 return Py_None;
4008 }
4009 }
4010 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4011 wxPyUserData* data = NULL;
4012 if ( userData ) {
4013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4014 data = new wxPyUserData(userData);
4015 wxPyEndBlockThreads(blocked);
4016 }
4017 self->SetUserData(data);
4018 }
4019
4020 // Figure out the type of the sizer item
4021
4022 struct wxPySizerItemInfo {
4023 wxPySizerItemInfo()
4024 : window(NULL), sizer(NULL), gotSize(false),
4025 size(wxDefaultSize), gotPos(false), pos(-1)
4026 {}
4027
4028 wxWindow* window;
4029 wxSizer* sizer;
4030 bool gotSize;
4031 wxSize size;
4032 bool gotPos;
4033 int pos;
4034 };
4035
4036 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4037
4038 wxPySizerItemInfo info;
4039 wxSize size;
4040 wxSize* sizePtr = &size;
4041
4042 // Find out what the type of the item is
4043 // try wxWindow
4044 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4045 PyErr_Clear();
4046 info.window = NULL;
4047
4048 // try wxSizer
4049 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4050 PyErr_Clear();
4051 info.sizer = NULL;
4052
4053 // try wxSize or (w,h)
4054 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4055 info.size = *sizePtr;
4056 info.gotSize = true;
4057 }
4058
4059 // or a single int
4060 if (checkIdx && PyInt_Check(item)) {
4061 info.pos = PyInt_AsLong(item);
4062 info.gotPos = true;
4063 }
4064 }
4065 }
4066
4067 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4068 // no expected type, figure out what kind of error message to generate
4069 if ( !checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4071 else if ( checkSize && !checkIdx )
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4073 else if ( !checkSize && checkIdx)
4074 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4075 else
4076 // can this one happen?
4077 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4078 }
4079
4080 return info;
4081 }
4082
4083 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4084 if (!self->GetClientObject())
4085 self->SetClientObject(new wxPyOORClientData(_self));
4086 }
4087 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4088
4089 wxPyUserData* data = NULL;
4090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4092 if ( userData && (info.window || info.sizer || info.gotSize) )
4093 data = new wxPyUserData(userData);
4094 if ( info.sizer )
4095 PyObject_SetAttrString(item,"thisown",Py_False);
4096 wxPyEndBlockThreads(blocked);
4097
4098 // Now call the real Add method if a valid item type was found
4099 if ( info.window )
4100 return self->Add(info.window, proportion, flag, border, data);
4101 else if ( info.sizer )
4102 return self->Add(info.sizer, proportion, flag, border, data);
4103 else if (info.gotSize)
4104 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4105 proportion, flag, border, data);
4106 else
4107 return NULL;
4108 }
4109 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4110
4111 wxPyUserData* data = NULL;
4112 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4113 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4114 if ( userData && (info.window || info.sizer || info.gotSize) )
4115 data = new wxPyUserData(userData);
4116 if ( info.sizer )
4117 PyObject_SetAttrString(item,"thisown",Py_False);
4118 wxPyEndBlockThreads(blocked);
4119
4120 // Now call the real Insert method if a valid item type was found
4121 if ( info.window )
4122 return self->Insert(before, info.window, proportion, flag, border, data);
4123 else if ( info.sizer )
4124 return self->Insert(before, info.sizer, proportion, flag, border, data);
4125 else if (info.gotSize)
4126 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4127 proportion, flag, border, data);
4128 else
4129 return NULL;
4130 }
4131 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4132
4133 wxPyUserData* data = NULL;
4134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4136 if ( userData && (info.window || info.sizer || info.gotSize) )
4137 data = new wxPyUserData(userData);
4138 if ( info.sizer )
4139 PyObject_SetAttrString(item,"thisown",Py_False);
4140 wxPyEndBlockThreads(blocked);
4141
4142 // Now call the real Prepend method if a valid item type was found
4143 if ( info.window )
4144 return self->Prepend(info.window, proportion, flag, border, data);
4145 else if ( info.sizer )
4146 return self->Prepend(info.sizer, proportion, flag, border, data);
4147 else if (info.gotSize)
4148 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4149 proportion, flag, border, data);
4150 else
4151 return NULL;
4152 }
4153 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4156 wxPyEndBlockThreads(blocked);
4157 if ( info.window )
4158 return self->Remove(info.window);
4159 else if ( info.sizer )
4160 return self->Remove(info.sizer);
4161 else if ( info.gotPos )
4162 return self->Remove(info.pos);
4163 else
4164 return false;
4165 }
4166 SWIGINTERN bool wxSizer_Detach(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->Detach(info.window);
4172 else if ( info.sizer )
4173 return self->Detach(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Detach(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN wxSizerItem *wxSizer_GetItem(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->GetItem(info.window);
4185 else if ( info.sizer )
4186 return self->GetItem(info.sizer);
4187 else if ( info.gotPos )
4188 return self->GetItem(info.pos);
4189 else
4190 return NULL;
4191 }
4192 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 self->SetItemMinSize(info.window, size);
4198 else if ( info.sizer )
4199 self->SetItemMinSize(info.sizer, size);
4200 else if ( info.gotPos )
4201 self->SetItemMinSize(info.pos, size);
4202 }
4203 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4204 wxSizerItemList& list = self->GetChildren();
4205 return wxPy_ConvertList(&list);
4206 }
4207 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 return self->Show(info.window, show, recursive);
4213 else if ( info.sizer )
4214 return self->Show(info.sizer, show, recursive);
4215 else if ( info.gotPos )
4216 return self->Show(info.pos, show);
4217 else
4218 return false;
4219 }
4220 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->IsShown(info.window);
4226 else if ( info.sizer )
4227 return self->IsShown(info.sizer);
4228 else if ( info.gotPos )
4229 return self->IsShown(info.pos);
4230 else
4231 return false;
4232 }
4233
4234 // See pyclasses.h
4235 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4236 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4237 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4238
4239
4240
4241
4242 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4243 {
4244 if (source == Py_None) {
4245 **obj = wxGBPosition(-1,-1);
4246 return true;
4247 }
4248 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4249 }
4250
4251 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4252 {
4253 if (source == Py_None) {
4254 **obj = wxGBSpan(-1,-1);
4255 return true;
4256 }
4257 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4258 }
4259
4260
4261 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4262 wxGBPosition temp, *obj = &temp;
4263 if ( other == Py_None ) return false;
4264 if ( ! wxGBPosition_helper(other, &obj) ) {
4265 PyErr_Clear();
4266 return false;
4267 }
4268 return self->operator==(*obj);
4269 }
4270 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4271 wxGBPosition temp, *obj = &temp;
4272 if ( other == Py_None ) return true;
4273 if ( ! wxGBPosition_helper(other, &obj)) {
4274 PyErr_Clear();
4275 return true;
4276 }
4277 return self->operator!=(*obj);
4278 }
4279 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4280 self->SetRow(row);
4281 self->SetCol(col);
4282 }
4283 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4284 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4285 PyObject* tup = PyTuple_New(2);
4286 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4287 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4288 wxPyEndBlockThreads(blocked);
4289 return tup;
4290 }
4291 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4292 wxGBSpan temp, *obj = &temp;
4293 if ( other == Py_None ) return false;
4294 if ( ! wxGBSpan_helper(other, &obj) ) {
4295 PyErr_Clear();
4296 return false;
4297 }
4298 return self->operator==(*obj);
4299 }
4300 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4301 wxGBSpan temp, *obj = &temp;
4302 if ( other == Py_None ) return true;
4303 if ( ! wxGBSpan_helper(other, &obj)) {
4304 PyErr_Clear();
4305 return true;
4306 }
4307 return self->operator!=(*obj);
4308 }
4309 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4310 self->SetRowspan(rowspan);
4311 self->SetColspan(colspan);
4312 }
4313 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4314 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4315 PyObject* tup = PyTuple_New(2);
4316 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4317 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4318 wxPyEndBlockThreads(blocked);
4319 return tup;
4320 }
4321 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4322 wxPyUserData* data = NULL;
4323 if ( userData ) {
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 data = new wxPyUserData(userData);
4326 wxPyEndBlockThreads(blocked);
4327 }
4328 return new wxGBSizerItem(window, pos, span, flag, border, data);
4329 }
4330 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4331 wxPyUserData* data = NULL;
4332 if ( userData ) {
4333 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4334 data = new wxPyUserData(userData);
4335 wxPyEndBlockThreads(blocked);
4336 }
4337 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4338 }
4339 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4340 wxPyUserData* data = NULL;
4341 if ( userData ) {
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 data = new wxPyUserData(userData);
4344 wxPyEndBlockThreads(blocked);
4345 }
4346 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4347 }
4348 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4349 int row, col;
4350 self->GetEndPos(row, col);
4351 return wxGBPosition(row, col);
4352 }
4353 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4354
4355 wxPyUserData* data = NULL;
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4358 if ( userData && (info.window || info.sizer || info.gotSize) )
4359 data = new wxPyUserData(userData);
4360 if ( info.sizer )
4361 PyObject_SetAttrString(item,"thisown",Py_False);
4362 wxPyEndBlockThreads(blocked);
4363
4364 // Now call the real Add method if a valid item type was found
4365 if ( info.window )
4366 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4367 else if ( info.sizer )
4368 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4369 else if (info.gotSize)
4370 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4371 pos, span, flag, border, data);
4372 return NULL;
4373 }
4374
4375
4376 #ifdef __cplusplus
4377 extern "C" {
4378 #endif
4379 SWIGINTERN int EmptyString_set(PyObject *) {
4380 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4381 return 1;
4382 }
4383
4384
4385 SWIGINTERN PyObject *EmptyString_get(void) {
4386 PyObject *pyobj = 0;
4387
4388 {
4389 #if wxUSE_UNICODE
4390 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #else
4392 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4393 #endif
4394 }
4395 return pyobj;
4396 }
4397
4398
4399 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4400 PyObject *resultobj = 0;
4401 wxObject *arg1 = (wxObject *) 0 ;
4402 wxString result;
4403 void *argp1 = 0 ;
4404 int res1 = 0 ;
4405 PyObject *swig_obj[1] ;
4406
4407 if (!args) SWIG_fail;
4408 swig_obj[0] = args;
4409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4410 if (!SWIG_IsOK(res1)) {
4411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4412 }
4413 arg1 = reinterpret_cast< wxObject * >(argp1);
4414 {
4415 PyThreadState* __tstate = wxPyBeginAllowThreads();
4416 result = wxObject_GetClassName(arg1);
4417 wxPyEndAllowThreads(__tstate);
4418 if (PyErr_Occurred()) SWIG_fail;
4419 }
4420 {
4421 #if wxUSE_UNICODE
4422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4423 #else
4424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4425 #endif
4426 }
4427 return resultobj;
4428 fail:
4429 return NULL;
4430 }
4431
4432
4433 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4434 PyObject *resultobj = 0;
4435 wxObject *arg1 = (wxObject *) 0 ;
4436 void *argp1 = 0 ;
4437 int res1 = 0 ;
4438 PyObject *swig_obj[1] ;
4439
4440 if (!args) SWIG_fail;
4441 swig_obj[0] = args;
4442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4443 if (!SWIG_IsOK(res1)) {
4444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4445 }
4446 arg1 = reinterpret_cast< wxObject * >(argp1);
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 wxObject_Destroy(arg1);
4450 wxPyEndAllowThreads(__tstate);
4451 if (PyErr_Occurred()) SWIG_fail;
4452 }
4453 resultobj = SWIG_Py_Void();
4454 return resultobj;
4455 fail:
4456 return NULL;
4457 }
4458
4459
4460 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4461 PyObject *obj;
4462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4463 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4464 return SWIG_Py_Void();
4465 }
4466
4467 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4468 PyObject *resultobj = 0;
4469 wxSize *arg1 = (wxSize *) 0 ;
4470 int arg2 ;
4471 void *argp1 = 0 ;
4472 int res1 = 0 ;
4473 int val2 ;
4474 int ecode2 = 0 ;
4475 PyObject *swig_obj[2] ;
4476
4477 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4479 if (!SWIG_IsOK(res1)) {
4480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4481 }
4482 arg1 = reinterpret_cast< wxSize * >(argp1);
4483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4484 if (!SWIG_IsOK(ecode2)) {
4485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4486 }
4487 arg2 = static_cast< int >(val2);
4488 if (arg1) (arg1)->x = arg2;
4489
4490 resultobj = SWIG_Py_Void();
4491 return resultobj;
4492 fail:
4493 return NULL;
4494 }
4495
4496
4497 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4498 PyObject *resultobj = 0;
4499 wxSize *arg1 = (wxSize *) 0 ;
4500 int result;
4501 void *argp1 = 0 ;
4502 int res1 = 0 ;
4503 PyObject *swig_obj[1] ;
4504
4505 if (!args) SWIG_fail;
4506 swig_obj[0] = args;
4507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4508 if (!SWIG_IsOK(res1)) {
4509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4510 }
4511 arg1 = reinterpret_cast< wxSize * >(argp1);
4512 result = (int) ((arg1)->x);
4513 resultobj = SWIG_From_int(static_cast< int >(result));
4514 return resultobj;
4515 fail:
4516 return NULL;
4517 }
4518
4519
4520 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4521 PyObject *resultobj = 0;
4522 wxSize *arg1 = (wxSize *) 0 ;
4523 int arg2 ;
4524 void *argp1 = 0 ;
4525 int res1 = 0 ;
4526 int val2 ;
4527 int ecode2 = 0 ;
4528 PyObject *swig_obj[2] ;
4529
4530 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4532 if (!SWIG_IsOK(res1)) {
4533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4534 }
4535 arg1 = reinterpret_cast< wxSize * >(argp1);
4536 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4537 if (!SWIG_IsOK(ecode2)) {
4538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4539 }
4540 arg2 = static_cast< int >(val2);
4541 if (arg1) (arg1)->y = arg2;
4542
4543 resultobj = SWIG_Py_Void();
4544 return resultobj;
4545 fail:
4546 return NULL;
4547 }
4548
4549
4550 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4551 PyObject *resultobj = 0;
4552 wxSize *arg1 = (wxSize *) 0 ;
4553 int result;
4554 void *argp1 = 0 ;
4555 int res1 = 0 ;
4556 PyObject *swig_obj[1] ;
4557
4558 if (!args) SWIG_fail;
4559 swig_obj[0] = args;
4560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4561 if (!SWIG_IsOK(res1)) {
4562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4563 }
4564 arg1 = reinterpret_cast< wxSize * >(argp1);
4565 result = (int) ((arg1)->y);
4566 resultobj = SWIG_From_int(static_cast< int >(result));
4567 return resultobj;
4568 fail:
4569 return NULL;
4570 }
4571
4572
4573 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4574 PyObject *resultobj = 0;
4575 int arg1 = (int) 0 ;
4576 int arg2 = (int) 0 ;
4577 wxSize *result = 0 ;
4578 int val1 ;
4579 int ecode1 = 0 ;
4580 int val2 ;
4581 int ecode2 = 0 ;
4582 PyObject * obj0 = 0 ;
4583 PyObject * obj1 = 0 ;
4584 char * kwnames[] = {
4585 (char *) "w",(char *) "h", NULL
4586 };
4587
4588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4589 if (obj0) {
4590 ecode1 = SWIG_AsVal_int(obj0, &val1);
4591 if (!SWIG_IsOK(ecode1)) {
4592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4593 }
4594 arg1 = static_cast< int >(val1);
4595 }
4596 if (obj1) {
4597 ecode2 = SWIG_AsVal_int(obj1, &val2);
4598 if (!SWIG_IsOK(ecode2)) {
4599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4600 }
4601 arg2 = static_cast< int >(val2);
4602 }
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 result = (wxSize *)new wxSize(arg1,arg2);
4606 wxPyEndAllowThreads(__tstate);
4607 if (PyErr_Occurred()) SWIG_fail;
4608 }
4609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4610 return resultobj;
4611 fail:
4612 return NULL;
4613 }
4614
4615
4616 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4617 PyObject *resultobj = 0;
4618 wxSize *arg1 = (wxSize *) 0 ;
4619 void *argp1 = 0 ;
4620 int res1 = 0 ;
4621 PyObject *swig_obj[1] ;
4622
4623 if (!args) SWIG_fail;
4624 swig_obj[0] = args;
4625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4626 if (!SWIG_IsOK(res1)) {
4627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4628 }
4629 arg1 = reinterpret_cast< wxSize * >(argp1);
4630 {
4631 PyThreadState* __tstate = wxPyBeginAllowThreads();
4632 delete arg1;
4633
4634 wxPyEndAllowThreads(__tstate);
4635 if (PyErr_Occurred()) SWIG_fail;
4636 }
4637 resultobj = SWIG_Py_Void();
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj = 0;
4646 wxSize *arg1 = (wxSize *) 0 ;
4647 PyObject *arg2 = (PyObject *) 0 ;
4648 bool result;
4649 void *argp1 = 0 ;
4650 int res1 = 0 ;
4651 PyObject * obj0 = 0 ;
4652 PyObject * obj1 = 0 ;
4653 char * kwnames[] = {
4654 (char *) "self",(char *) "other", NULL
4655 };
4656
4657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4659 if (!SWIG_IsOK(res1)) {
4660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4661 }
4662 arg1 = reinterpret_cast< wxSize * >(argp1);
4663 arg2 = obj1;
4664 {
4665 result = (bool)wxSize___eq__(arg1,arg2);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 {
4669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4670 }
4671 return resultobj;
4672 fail:
4673 return NULL;
4674 }
4675
4676
4677 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4678 PyObject *resultobj = 0;
4679 wxSize *arg1 = (wxSize *) 0 ;
4680 PyObject *arg2 = (PyObject *) 0 ;
4681 bool result;
4682 void *argp1 = 0 ;
4683 int res1 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "self",(char *) "other", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4694 }
4695 arg1 = reinterpret_cast< wxSize * >(argp1);
4696 arg2 = obj1;
4697 {
4698 result = (bool)wxSize___ne__(arg1,arg2);
4699 if (PyErr_Occurred()) SWIG_fail;
4700 }
4701 {
4702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4703 }
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4711 PyObject *resultobj = 0;
4712 wxSize *arg1 = (wxSize *) 0 ;
4713 wxSize *arg2 = 0 ;
4714 wxSize result;
4715 void *argp1 = 0 ;
4716 int res1 = 0 ;
4717 wxSize temp2 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 char * kwnames[] = {
4721 (char *) "self",(char *) "sz", NULL
4722 };
4723
4724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 arg2 = &temp2;
4732 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4733 }
4734 {
4735 PyThreadState* __tstate = wxPyBeginAllowThreads();
4736 result = (arg1)->operator +((wxSize const &)*arg2);
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4741 return resultobj;
4742 fail:
4743 return NULL;
4744 }
4745
4746
4747 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4748 PyObject *resultobj = 0;
4749 wxSize *arg1 = (wxSize *) 0 ;
4750 wxSize *arg2 = 0 ;
4751 wxSize result;
4752 void *argp1 = 0 ;
4753 int res1 = 0 ;
4754 wxSize temp2 ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char * kwnames[] = {
4758 (char *) "self",(char *) "sz", NULL
4759 };
4760
4761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4763 if (!SWIG_IsOK(res1)) {
4764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4765 }
4766 arg1 = reinterpret_cast< wxSize * >(argp1);
4767 {
4768 arg2 = &temp2;
4769 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4770 }
4771 {
4772 PyThreadState* __tstate = wxPyBeginAllowThreads();
4773 result = (arg1)->operator -((wxSize const &)*arg2);
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4778 return resultobj;
4779 fail:
4780 return NULL;
4781 }
4782
4783
4784 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4785 PyObject *resultobj = 0;
4786 wxSize *arg1 = (wxSize *) 0 ;
4787 wxSize *arg2 = 0 ;
4788 void *argp1 = 0 ;
4789 int res1 = 0 ;
4790 wxSize temp2 ;
4791 PyObject * obj0 = 0 ;
4792 PyObject * obj1 = 0 ;
4793 char * kwnames[] = {
4794 (char *) "self",(char *) "sz", NULL
4795 };
4796
4797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4799 if (!SWIG_IsOK(res1)) {
4800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4801 }
4802 arg1 = reinterpret_cast< wxSize * >(argp1);
4803 {
4804 arg2 = &temp2;
4805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 (arg1)->IncTo((wxSize const &)*arg2);
4810 wxPyEndAllowThreads(__tstate);
4811 if (PyErr_Occurred()) SWIG_fail;
4812 }
4813 resultobj = SWIG_Py_Void();
4814 return resultobj;
4815 fail:
4816 return NULL;
4817 }
4818
4819
4820 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4821 PyObject *resultobj = 0;
4822 wxSize *arg1 = (wxSize *) 0 ;
4823 wxSize *arg2 = 0 ;
4824 void *argp1 = 0 ;
4825 int res1 = 0 ;
4826 wxSize temp2 ;
4827 PyObject * obj0 = 0 ;
4828 PyObject * obj1 = 0 ;
4829 char * kwnames[] = {
4830 (char *) "self",(char *) "sz", NULL
4831 };
4832
4833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4835 if (!SWIG_IsOK(res1)) {
4836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4837 }
4838 arg1 = reinterpret_cast< wxSize * >(argp1);
4839 {
4840 arg2 = &temp2;
4841 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4842 }
4843 {
4844 PyThreadState* __tstate = wxPyBeginAllowThreads();
4845 (arg1)->DecTo((wxSize const &)*arg2);
4846 wxPyEndAllowThreads(__tstate);
4847 if (PyErr_Occurred()) SWIG_fail;
4848 }
4849 resultobj = SWIG_Py_Void();
4850 return resultobj;
4851 fail:
4852 return NULL;
4853 }
4854
4855
4856 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4857 PyObject *resultobj = 0;
4858 wxSize *arg1 = (wxSize *) 0 ;
4859 int arg2 ;
4860 int arg3 ;
4861 void *argp1 = 0 ;
4862 int res1 = 0 ;
4863 int val2 ;
4864 int ecode2 = 0 ;
4865 int val3 ;
4866 int ecode3 = 0 ;
4867 PyObject * obj0 = 0 ;
4868 PyObject * obj1 = 0 ;
4869 PyObject * obj2 = 0 ;
4870 char * kwnames[] = {
4871 (char *) "self",(char *) "dx",(char *) "dy", NULL
4872 };
4873
4874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4876 if (!SWIG_IsOK(res1)) {
4877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4878 }
4879 arg1 = reinterpret_cast< wxSize * >(argp1);
4880 ecode2 = SWIG_AsVal_int(obj1, &val2);
4881 if (!SWIG_IsOK(ecode2)) {
4882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4883 }
4884 arg2 = static_cast< int >(val2);
4885 ecode3 = SWIG_AsVal_int(obj2, &val3);
4886 if (!SWIG_IsOK(ecode3)) {
4887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4888 }
4889 arg3 = static_cast< int >(val3);
4890 {
4891 PyThreadState* __tstate = wxPyBeginAllowThreads();
4892 (arg1)->IncBy(arg2,arg3);
4893 wxPyEndAllowThreads(__tstate);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 resultobj = SWIG_Py_Void();
4897 return resultobj;
4898 fail:
4899 return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4904 PyObject *resultobj = 0;
4905 wxSize *arg1 = (wxSize *) 0 ;
4906 int arg2 ;
4907 int arg3 ;
4908 void *argp1 = 0 ;
4909 int res1 = 0 ;
4910 int val2 ;
4911 int ecode2 = 0 ;
4912 int val3 ;
4913 int ecode3 = 0 ;
4914 PyObject * obj0 = 0 ;
4915 PyObject * obj1 = 0 ;
4916 PyObject * obj2 = 0 ;
4917 char * kwnames[] = {
4918 (char *) "self",(char *) "dx",(char *) "dy", NULL
4919 };
4920
4921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4923 if (!SWIG_IsOK(res1)) {
4924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4925 }
4926 arg1 = reinterpret_cast< wxSize * >(argp1);
4927 ecode2 = SWIG_AsVal_int(obj1, &val2);
4928 if (!SWIG_IsOK(ecode2)) {
4929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4930 }
4931 arg2 = static_cast< int >(val2);
4932 ecode3 = SWIG_AsVal_int(obj2, &val3);
4933 if (!SWIG_IsOK(ecode3)) {
4934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4935 }
4936 arg3 = static_cast< int >(val3);
4937 {
4938 PyThreadState* __tstate = wxPyBeginAllowThreads();
4939 (arg1)->DecBy(arg2,arg3);
4940 wxPyEndAllowThreads(__tstate);
4941 if (PyErr_Occurred()) SWIG_fail;
4942 }
4943 resultobj = SWIG_Py_Void();
4944 return resultobj;
4945 fail:
4946 return NULL;
4947 }
4948
4949
4950 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4951 PyObject *resultobj = 0;
4952 wxSize *arg1 = (wxSize *) 0 ;
4953 float arg2 ;
4954 float arg3 ;
4955 void *argp1 = 0 ;
4956 int res1 = 0 ;
4957 float val2 ;
4958 int ecode2 = 0 ;
4959 float val3 ;
4960 int ecode3 = 0 ;
4961 PyObject * obj0 = 0 ;
4962 PyObject * obj1 = 0 ;
4963 PyObject * obj2 = 0 ;
4964 char * kwnames[] = {
4965 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4966 };
4967
4968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4970 if (!SWIG_IsOK(res1)) {
4971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4972 }
4973 arg1 = reinterpret_cast< wxSize * >(argp1);
4974 ecode2 = SWIG_AsVal_float(obj1, &val2);
4975 if (!SWIG_IsOK(ecode2)) {
4976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4977 }
4978 arg2 = static_cast< float >(val2);
4979 ecode3 = SWIG_AsVal_float(obj2, &val3);
4980 if (!SWIG_IsOK(ecode3)) {
4981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4982 }
4983 arg3 = static_cast< float >(val3);
4984 {
4985 PyThreadState* __tstate = wxPyBeginAllowThreads();
4986 (arg1)->Scale(arg2,arg3);
4987 wxPyEndAllowThreads(__tstate);
4988 if (PyErr_Occurred()) SWIG_fail;
4989 }
4990 resultobj = SWIG_Py_Void();
4991 return resultobj;
4992 fail:
4993 return NULL;
4994 }
4995
4996
4997 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4998 PyObject *resultobj = 0;
4999 wxSize *arg1 = (wxSize *) 0 ;
5000 int arg2 ;
5001 int arg3 ;
5002 void *argp1 = 0 ;
5003 int res1 = 0 ;
5004 int val2 ;
5005 int ecode2 = 0 ;
5006 int val3 ;
5007 int ecode3 = 0 ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "w",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 ecode3 = SWIG_AsVal_int(obj2, &val3);
5027 if (!SWIG_IsOK(ecode3)) {
5028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5029 }
5030 arg3 = static_cast< int >(val3);
5031 {
5032 PyThreadState* __tstate = wxPyBeginAllowThreads();
5033 (arg1)->Set(arg2,arg3);
5034 wxPyEndAllowThreads(__tstate);
5035 if (PyErr_Occurred()) SWIG_fail;
5036 }
5037 resultobj = SWIG_Py_Void();
5038 return resultobj;
5039 fail:
5040 return NULL;
5041 }
5042
5043
5044 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5045 PyObject *resultobj = 0;
5046 wxSize *arg1 = (wxSize *) 0 ;
5047 int arg2 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 int val2 ;
5051 int ecode2 = 0 ;
5052 PyObject * obj0 = 0 ;
5053 PyObject * obj1 = 0 ;
5054 char * kwnames[] = {
5055 (char *) "self",(char *) "w", NULL
5056 };
5057
5058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5060 if (!SWIG_IsOK(res1)) {
5061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 ecode2 = SWIG_AsVal_int(obj1, &val2);
5065 if (!SWIG_IsOK(ecode2)) {
5066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5067 }
5068 arg2 = static_cast< int >(val2);
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 (arg1)->SetWidth(arg2);
5072 wxPyEndAllowThreads(__tstate);
5073 if (PyErr_Occurred()) SWIG_fail;
5074 }
5075 resultobj = SWIG_Py_Void();
5076 return resultobj;
5077 fail:
5078 return NULL;
5079 }
5080
5081
5082 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5083 PyObject *resultobj = 0;
5084 wxSize *arg1 = (wxSize *) 0 ;
5085 int arg2 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 PyObject * obj0 = 0 ;
5091 PyObject * obj1 = 0 ;
5092 char * kwnames[] = {
5093 (char *) "self",(char *) "h", NULL
5094 };
5095
5096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5098 if (!SWIG_IsOK(res1)) {
5099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5100 }
5101 arg1 = reinterpret_cast< wxSize * >(argp1);
5102 ecode2 = SWIG_AsVal_int(obj1, &val2);
5103 if (!SWIG_IsOK(ecode2)) {
5104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5105 }
5106 arg2 = static_cast< int >(val2);
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 (arg1)->SetHeight(arg2);
5110 wxPyEndAllowThreads(__tstate);
5111 if (PyErr_Occurred()) SWIG_fail;
5112 }
5113 resultobj = SWIG_Py_Void();
5114 return resultobj;
5115 fail:
5116 return NULL;
5117 }
5118
5119
5120 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 wxSize *arg1 = (wxSize *) 0 ;
5123 int result;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 PyObject *swig_obj[1] ;
5127
5128 if (!args) SWIG_fail;
5129 swig_obj[0] = args;
5130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5131 if (!SWIG_IsOK(res1)) {
5132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5133 }
5134 arg1 = reinterpret_cast< wxSize * >(argp1);
5135 {
5136 PyThreadState* __tstate = wxPyBeginAllowThreads();
5137 result = (int)((wxSize const *)arg1)->GetWidth();
5138 wxPyEndAllowThreads(__tstate);
5139 if (PyErr_Occurred()) SWIG_fail;
5140 }
5141 resultobj = SWIG_From_int(static_cast< int >(result));
5142 return resultobj;
5143 fail:
5144 return NULL;
5145 }
5146
5147
5148 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5149 PyObject *resultobj = 0;
5150 wxSize *arg1 = (wxSize *) 0 ;
5151 int result;
5152 void *argp1 = 0 ;
5153 int res1 = 0 ;
5154 PyObject *swig_obj[1] ;
5155
5156 if (!args) SWIG_fail;
5157 swig_obj[0] = args;
5158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5161 }
5162 arg1 = reinterpret_cast< wxSize * >(argp1);
5163 {
5164 PyThreadState* __tstate = wxPyBeginAllowThreads();
5165 result = (int)((wxSize const *)arg1)->GetHeight();
5166 wxPyEndAllowThreads(__tstate);
5167 if (PyErr_Occurred()) SWIG_fail;
5168 }
5169 resultobj = SWIG_From_int(static_cast< int >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxSize *arg1 = (wxSize *) 0 ;
5179 bool result;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 PyObject *swig_obj[1] ;
5183
5184 if (!args) SWIG_fail;
5185 swig_obj[0] = args;
5186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5187 if (!SWIG_IsOK(res1)) {
5188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5189 }
5190 arg1 = reinterpret_cast< wxSize * >(argp1);
5191 {
5192 PyThreadState* __tstate = wxPyBeginAllowThreads();
5193 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5194 wxPyEndAllowThreads(__tstate);
5195 if (PyErr_Occurred()) SWIG_fail;
5196 }
5197 {
5198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5199 }
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj = 0;
5208 wxSize *arg1 = (wxSize *) 0 ;
5209 wxSize *arg2 = 0 ;
5210 void *argp1 = 0 ;
5211 int res1 = 0 ;
5212 wxSize temp2 ;
5213 PyObject * obj0 = 0 ;
5214 PyObject * obj1 = 0 ;
5215 char * kwnames[] = {
5216 (char *) "self",(char *) "size", NULL
5217 };
5218
5219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5221 if (!SWIG_IsOK(res1)) {
5222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5223 }
5224 arg1 = reinterpret_cast< wxSize * >(argp1);
5225 {
5226 arg2 = &temp2;
5227 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5228 }
5229 {
5230 PyThreadState* __tstate = wxPyBeginAllowThreads();
5231 (arg1)->SetDefaults((wxSize const &)*arg2);
5232 wxPyEndAllowThreads(__tstate);
5233 if (PyErr_Occurred()) SWIG_fail;
5234 }
5235 resultobj = SWIG_Py_Void();
5236 return resultobj;
5237 fail:
5238 return NULL;
5239 }
5240
5241
5242 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5243 PyObject *resultobj = 0;
5244 wxSize *arg1 = (wxSize *) 0 ;
5245 PyObject *result = 0 ;
5246 void *argp1 = 0 ;
5247 int res1 = 0 ;
5248 PyObject *swig_obj[1] ;
5249
5250 if (!args) SWIG_fail;
5251 swig_obj[0] = args;
5252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5253 if (!SWIG_IsOK(res1)) {
5254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5255 }
5256 arg1 = reinterpret_cast< wxSize * >(argp1);
5257 {
5258 PyThreadState* __tstate = wxPyBeginAllowThreads();
5259 result = (PyObject *)wxSize_Get(arg1);
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 resultobj = result;
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5271 PyObject *obj;
5272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5273 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5274 return SWIG_Py_Void();
5275 }
5276
5277 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5278 return SWIG_Python_InitShadowInstance(args);
5279 }
5280
5281 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 PyObject *resultobj = 0;
5283 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5284 double arg2 ;
5285 void *argp1 = 0 ;
5286 int res1 = 0 ;
5287 double val2 ;
5288 int ecode2 = 0 ;
5289 PyObject *swig_obj[2] ;
5290
5291 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5295 }
5296 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5297 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5298 if (!SWIG_IsOK(ecode2)) {
5299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5300 }
5301 arg2 = static_cast< double >(val2);
5302 if (arg1) (arg1)->x = arg2;
5303
5304 resultobj = SWIG_Py_Void();
5305 return resultobj;
5306 fail:
5307 return NULL;
5308 }
5309
5310
5311 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5312 PyObject *resultobj = 0;
5313 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5314 double result;
5315 void *argp1 = 0 ;
5316 int res1 = 0 ;
5317 PyObject *swig_obj[1] ;
5318
5319 if (!args) SWIG_fail;
5320 swig_obj[0] = args;
5321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5322 if (!SWIG_IsOK(res1)) {
5323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5324 }
5325 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5326 result = (double) ((arg1)->x);
5327 resultobj = SWIG_From_double(static_cast< double >(result));
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 double arg2 ;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 double val2 ;
5341 int ecode2 = 0 ;
5342 PyObject *swig_obj[2] ;
5343
5344 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5346 if (!SWIG_IsOK(res1)) {
5347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5348 }
5349 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5350 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5351 if (!SWIG_IsOK(ecode2)) {
5352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5353 }
5354 arg2 = static_cast< double >(val2);
5355 if (arg1) (arg1)->y = arg2;
5356
5357 resultobj = SWIG_Py_Void();
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 PyObject *resultobj = 0;
5366 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5367 double result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 PyObject *swig_obj[1] ;
5371
5372 if (!args) SWIG_fail;
5373 swig_obj[0] = args;
5374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5375 if (!SWIG_IsOK(res1)) {
5376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5377 }
5378 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5379 result = (double) ((arg1)->y);
5380 resultobj = SWIG_From_double(static_cast< double >(result));
5381 return resultobj;
5382 fail:
5383 return NULL;
5384 }
5385
5386
5387 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5388 PyObject *resultobj = 0;
5389 double arg1 = (double) 0.0 ;
5390 double arg2 = (double) 0.0 ;
5391 wxRealPoint *result = 0 ;
5392 double val1 ;
5393 int ecode1 = 0 ;
5394 double val2 ;
5395 int ecode2 = 0 ;
5396 PyObject * obj0 = 0 ;
5397 PyObject * obj1 = 0 ;
5398 char * kwnames[] = {
5399 (char *) "x",(char *) "y", NULL
5400 };
5401
5402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5403 if (obj0) {
5404 ecode1 = SWIG_AsVal_double(obj0, &val1);
5405 if (!SWIG_IsOK(ecode1)) {
5406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5407 }
5408 arg1 = static_cast< double >(val1);
5409 }
5410 if (obj1) {
5411 ecode2 = SWIG_AsVal_double(obj1, &val2);
5412 if (!SWIG_IsOK(ecode2)) {
5413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5414 }
5415 arg2 = static_cast< double >(val2);
5416 }
5417 {
5418 PyThreadState* __tstate = wxPyBeginAllowThreads();
5419 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5424 return resultobj;
5425 fail:
5426 return NULL;
5427 }
5428
5429
5430 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5431 PyObject *resultobj = 0;
5432 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 PyObject *swig_obj[1] ;
5436
5437 if (!args) SWIG_fail;
5438 swig_obj[0] = args;
5439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5440 if (!SWIG_IsOK(res1)) {
5441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5442 }
5443 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 delete arg1;
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 resultobj = SWIG_Py_Void();
5452 return resultobj;
5453 fail:
5454 return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5459 PyObject *resultobj = 0;
5460 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5461 PyObject *arg2 = (PyObject *) 0 ;
5462 bool result;
5463 void *argp1 = 0 ;
5464 int res1 = 0 ;
5465 PyObject * obj0 = 0 ;
5466 PyObject * obj1 = 0 ;
5467 char * kwnames[] = {
5468 (char *) "self",(char *) "other", NULL
5469 };
5470
5471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5473 if (!SWIG_IsOK(res1)) {
5474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5475 }
5476 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5477 arg2 = obj1;
5478 {
5479 result = (bool)wxRealPoint___eq__(arg1,arg2);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5484 }
5485 return resultobj;
5486 fail:
5487 return NULL;
5488 }
5489
5490
5491 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5492 PyObject *resultobj = 0;
5493 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5494 PyObject *arg2 = (PyObject *) 0 ;
5495 bool result;
5496 void *argp1 = 0 ;
5497 int res1 = 0 ;
5498 PyObject * obj0 = 0 ;
5499 PyObject * obj1 = 0 ;
5500 char * kwnames[] = {
5501 (char *) "self",(char *) "other", NULL
5502 };
5503
5504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 arg2 = obj1;
5511 {
5512 result = (bool)wxRealPoint___ne__(arg1,arg2);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj = 0;
5526 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5527 wxRealPoint *arg2 = 0 ;
5528 wxRealPoint result;
5529 void *argp1 = 0 ;
5530 int res1 = 0 ;
5531 wxRealPoint temp2 ;
5532 PyObject * obj0 = 0 ;
5533 PyObject * obj1 = 0 ;
5534 char * kwnames[] = {
5535 (char *) "self",(char *) "pt", NULL
5536 };
5537
5538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 {
5545 arg2 = &temp2;
5546 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5547 }
5548 {
5549 PyThreadState* __tstate = wxPyBeginAllowThreads();
5550 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5551 wxPyEndAllowThreads(__tstate);
5552 if (PyErr_Occurred()) SWIG_fail;
5553 }
5554 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5555 return resultobj;
5556 fail:
5557 return NULL;
5558 }
5559
5560
5561 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5562 PyObject *resultobj = 0;
5563 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5564 wxRealPoint *arg2 = 0 ;
5565 wxRealPoint result;
5566 void *argp1 = 0 ;
5567 int res1 = 0 ;
5568 wxRealPoint temp2 ;
5569 PyObject * obj0 = 0 ;
5570 PyObject * obj1 = 0 ;
5571 char * kwnames[] = {
5572 (char *) "self",(char *) "pt", NULL
5573 };
5574
5575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5577 if (!SWIG_IsOK(res1)) {
5578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5579 }
5580 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5581 {
5582 arg2 = &temp2;
5583 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5584 }
5585 {
5586 PyThreadState* __tstate = wxPyBeginAllowThreads();
5587 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5588 wxPyEndAllowThreads(__tstate);
5589 if (PyErr_Occurred()) SWIG_fail;
5590 }
5591 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5592 return resultobj;
5593 fail:
5594 return NULL;
5595 }
5596
5597
5598 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5599 PyObject *resultobj = 0;
5600 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5601 double arg2 ;
5602 double arg3 ;
5603 void *argp1 = 0 ;
5604 int res1 = 0 ;
5605 double val2 ;
5606 int ecode2 = 0 ;
5607 double val3 ;
5608 int ecode3 = 0 ;
5609 PyObject * obj0 = 0 ;
5610 PyObject * obj1 = 0 ;
5611 PyObject * obj2 = 0 ;
5612 char * kwnames[] = {
5613 (char *) "self",(char *) "x",(char *) "y", NULL
5614 };
5615
5616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5618 if (!SWIG_IsOK(res1)) {
5619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5620 }
5621 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5622 ecode2 = SWIG_AsVal_double(obj1, &val2);
5623 if (!SWIG_IsOK(ecode2)) {
5624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5625 }
5626 arg2 = static_cast< double >(val2);
5627 ecode3 = SWIG_AsVal_double(obj2, &val3);
5628 if (!SWIG_IsOK(ecode3)) {
5629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5630 }
5631 arg3 = static_cast< double >(val3);
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 wxRealPoint_Set(arg1,arg2,arg3);
5635 wxPyEndAllowThreads(__tstate);
5636 if (PyErr_Occurred()) SWIG_fail;
5637 }
5638 resultobj = SWIG_Py_Void();
5639 return resultobj;
5640 fail:
5641 return NULL;
5642 }
5643
5644
5645 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5646 PyObject *resultobj = 0;
5647 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5648 PyObject *result = 0 ;
5649 void *argp1 = 0 ;
5650 int res1 = 0 ;
5651 PyObject *swig_obj[1] ;
5652
5653 if (!args) SWIG_fail;
5654 swig_obj[0] = args;
5655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5656 if (!SWIG_IsOK(res1)) {
5657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5658 }
5659 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5660 {
5661 PyThreadState* __tstate = wxPyBeginAllowThreads();
5662 result = (PyObject *)wxRealPoint_Get(arg1);
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 resultobj = result;
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5674 PyObject *obj;
5675 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5676 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5677 return SWIG_Py_Void();
5678 }
5679
5680 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5681 return SWIG_Python_InitShadowInstance(args);
5682 }
5683
5684 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685 PyObject *resultobj = 0;
5686 wxPoint *arg1 = (wxPoint *) 0 ;
5687 int arg2 ;
5688 void *argp1 = 0 ;
5689 int res1 = 0 ;
5690 int val2 ;
5691 int ecode2 = 0 ;
5692 PyObject *swig_obj[2] ;
5693
5694 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5696 if (!SWIG_IsOK(res1)) {
5697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5698 }
5699 arg1 = reinterpret_cast< wxPoint * >(argp1);
5700 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5701 if (!SWIG_IsOK(ecode2)) {
5702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5703 }
5704 arg2 = static_cast< int >(val2);
5705 if (arg1) (arg1)->x = arg2;
5706
5707 resultobj = SWIG_Py_Void();
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 PyObject *resultobj = 0;
5716 wxPoint *arg1 = (wxPoint *) 0 ;
5717 int result;
5718 void *argp1 = 0 ;
5719 int res1 = 0 ;
5720 PyObject *swig_obj[1] ;
5721
5722 if (!args) SWIG_fail;
5723 swig_obj[0] = args;
5724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5725 if (!SWIG_IsOK(res1)) {
5726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5727 }
5728 arg1 = reinterpret_cast< wxPoint * >(argp1);
5729 result = (int) ((arg1)->x);
5730 resultobj = SWIG_From_int(static_cast< int >(result));
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 int arg2 ;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 int val2 ;
5744 int ecode2 = 0 ;
5745 PyObject *swig_obj[2] ;
5746
5747 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5749 if (!SWIG_IsOK(res1)) {
5750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5751 }
5752 arg1 = reinterpret_cast< wxPoint * >(argp1);
5753 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5754 if (!SWIG_IsOK(ecode2)) {
5755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5756 }
5757 arg2 = static_cast< int >(val2);
5758 if (arg1) (arg1)->y = arg2;
5759
5760 resultobj = SWIG_Py_Void();
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5768 PyObject *resultobj = 0;
5769 wxPoint *arg1 = (wxPoint *) 0 ;
5770 int result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 PyObject *swig_obj[1] ;
5774
5775 if (!args) SWIG_fail;
5776 swig_obj[0] = args;
5777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5778 if (!SWIG_IsOK(res1)) {
5779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5780 }
5781 arg1 = reinterpret_cast< wxPoint * >(argp1);
5782 result = (int) ((arg1)->y);
5783 resultobj = SWIG_From_int(static_cast< int >(result));
5784 return resultobj;
5785 fail:
5786 return NULL;
5787 }
5788
5789
5790 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5791 PyObject *resultobj = 0;
5792 int arg1 = (int) 0 ;
5793 int arg2 = (int) 0 ;
5794 wxPoint *result = 0 ;
5795 int val1 ;
5796 int ecode1 = 0 ;
5797 int val2 ;
5798 int ecode2 = 0 ;
5799 PyObject * obj0 = 0 ;
5800 PyObject * obj1 = 0 ;
5801 char * kwnames[] = {
5802 (char *) "x",(char *) "y", NULL
5803 };
5804
5805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5806 if (obj0) {
5807 ecode1 = SWIG_AsVal_int(obj0, &val1);
5808 if (!SWIG_IsOK(ecode1)) {
5809 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5810 }
5811 arg1 = static_cast< int >(val1);
5812 }
5813 if (obj1) {
5814 ecode2 = SWIG_AsVal_int(obj1, &val2);
5815 if (!SWIG_IsOK(ecode2)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5817 }
5818 arg2 = static_cast< int >(val2);
5819 }
5820 {
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 result = (wxPoint *)new wxPoint(arg1,arg2);
5823 wxPyEndAllowThreads(__tstate);
5824 if (PyErr_Occurred()) SWIG_fail;
5825 }
5826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5827 return resultobj;
5828 fail:
5829 return NULL;
5830 }
5831
5832
5833 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5834 PyObject *resultobj = 0;
5835 wxPoint *arg1 = (wxPoint *) 0 ;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 PyObject *swig_obj[1] ;
5839
5840 if (!args) SWIG_fail;
5841 swig_obj[0] = args;
5842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 delete arg1;
5850
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 resultobj = SWIG_Py_Void();
5855 return resultobj;
5856 fail:
5857 return NULL;
5858 }
5859
5860
5861 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5862 PyObject *resultobj = 0;
5863 wxPoint *arg1 = (wxPoint *) 0 ;
5864 PyObject *arg2 = (PyObject *) 0 ;
5865 bool result;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 PyObject * obj0 = 0 ;
5869 PyObject * obj1 = 0 ;
5870 char * kwnames[] = {
5871 (char *) "self",(char *) "other", NULL
5872 };
5873
5874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5876 if (!SWIG_IsOK(res1)) {
5877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5878 }
5879 arg1 = reinterpret_cast< wxPoint * >(argp1);
5880 arg2 = obj1;
5881 {
5882 result = (bool)wxPoint___eq__(arg1,arg2);
5883 if (PyErr_Occurred()) SWIG_fail;
5884 }
5885 {
5886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5887 }
5888 return resultobj;
5889 fail:
5890 return NULL;
5891 }
5892
5893
5894 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5895 PyObject *resultobj = 0;
5896 wxPoint *arg1 = (wxPoint *) 0 ;
5897 PyObject *arg2 = (PyObject *) 0 ;
5898 bool result;
5899 void *argp1 = 0 ;
5900 int res1 = 0 ;
5901 PyObject * obj0 = 0 ;
5902 PyObject * obj1 = 0 ;
5903 char * kwnames[] = {
5904 (char *) "self",(char *) "other", NULL
5905 };
5906
5907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5909 if (!SWIG_IsOK(res1)) {
5910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5911 }
5912 arg1 = reinterpret_cast< wxPoint * >(argp1);
5913 arg2 = obj1;
5914 {
5915 result = (bool)wxPoint___ne__(arg1,arg2);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 {
5919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj = 0;
5929 wxPoint *arg1 = (wxPoint *) 0 ;
5930 wxPoint *arg2 = 0 ;
5931 wxPoint result;
5932 void *argp1 = 0 ;
5933 int res1 = 0 ;
5934 wxPoint temp2 ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "self",(char *) "pt", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5943 if (!SWIG_IsOK(res1)) {
5944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5945 }
5946 arg1 = reinterpret_cast< wxPoint * >(argp1);
5947 {
5948 arg2 = &temp2;
5949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5950 }
5951 {
5952 PyThreadState* __tstate = wxPyBeginAllowThreads();
5953 result = (arg1)->operator +((wxPoint const &)*arg2);
5954 wxPyEndAllowThreads(__tstate);
5955 if (PyErr_Occurred()) SWIG_fail;
5956 }
5957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxPoint *arg1 = (wxPoint *) 0 ;
5967 wxPoint *arg2 = 0 ;
5968 wxPoint result;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 wxPoint temp2 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 char * kwnames[] = {
5975 (char *) "self",(char *) "pt", NULL
5976 };
5977
5978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5982 }
5983 arg1 = reinterpret_cast< wxPoint * >(argp1);
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 result = (arg1)->operator -((wxPoint const &)*arg2);
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = (wxPoint *) 0 ;
6004 wxPoint *arg2 = 0 ;
6005 wxPoint *result = 0 ;
6006 void *argp1 = 0 ;
6007 int res1 = 0 ;
6008 wxPoint temp2 ;
6009 PyObject * obj0 = 0 ;
6010 PyObject * obj1 = 0 ;
6011 char * kwnames[] = {
6012 (char *) "self",(char *) "pt", NULL
6013 };
6014
6015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6017 if (!SWIG_IsOK(res1)) {
6018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6019 }
6020 arg1 = reinterpret_cast< wxPoint * >(argp1);
6021 {
6022 arg2 = &temp2;
6023 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6024 }
6025 {
6026 PyThreadState* __tstate = wxPyBeginAllowThreads();
6027 {
6028 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6029 result = (wxPoint *) &_result_ref;
6030 }
6031 wxPyEndAllowThreads(__tstate);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6035 return resultobj;
6036 fail:
6037 return NULL;
6038 }
6039
6040
6041 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6042 PyObject *resultobj = 0;
6043 wxPoint *arg1 = (wxPoint *) 0 ;
6044 wxPoint *arg2 = 0 ;
6045 wxPoint *result = 0 ;
6046 void *argp1 = 0 ;
6047 int res1 = 0 ;
6048 wxPoint temp2 ;
6049 PyObject * obj0 = 0 ;
6050 PyObject * obj1 = 0 ;
6051 char * kwnames[] = {
6052 (char *) "self",(char *) "pt", NULL
6053 };
6054
6055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6057 if (!SWIG_IsOK(res1)) {
6058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6059 }
6060 arg1 = reinterpret_cast< wxPoint * >(argp1);
6061 {
6062 arg2 = &temp2;
6063 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6064 }
6065 {
6066 PyThreadState* __tstate = wxPyBeginAllowThreads();
6067 {
6068 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6069 result = (wxPoint *) &_result_ref;
6070 }
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj = 0;
6083 wxPoint *arg1 = (wxPoint *) 0 ;
6084 long arg2 ;
6085 long arg3 ;
6086 void *argp1 = 0 ;
6087 int res1 = 0 ;
6088 long val2 ;
6089 int ecode2 = 0 ;
6090 long val3 ;
6091 int ecode3 = 0 ;
6092 PyObject * obj0 = 0 ;
6093 PyObject * obj1 = 0 ;
6094 PyObject * obj2 = 0 ;
6095 char * kwnames[] = {
6096 (char *) "self",(char *) "x",(char *) "y", NULL
6097 };
6098
6099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6101 if (!SWIG_IsOK(res1)) {
6102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6103 }
6104 arg1 = reinterpret_cast< wxPoint * >(argp1);
6105 ecode2 = SWIG_AsVal_long(obj1, &val2);
6106 if (!SWIG_IsOK(ecode2)) {
6107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6108 }
6109 arg2 = static_cast< long >(val2);
6110 ecode3 = SWIG_AsVal_long(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6113 }
6114 arg3 = static_cast< long >(val3);
6115 {
6116 PyThreadState* __tstate = wxPyBeginAllowThreads();
6117 wxPoint_Set(arg1,arg2,arg3);
6118 wxPyEndAllowThreads(__tstate);
6119 if (PyErr_Occurred()) SWIG_fail;
6120 }
6121 resultobj = SWIG_Py_Void();
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6129 PyObject *resultobj = 0;
6130 wxPoint *arg1 = (wxPoint *) 0 ;
6131 PyObject *result = 0 ;
6132 void *argp1 = 0 ;
6133 int res1 = 0 ;
6134 PyObject *swig_obj[1] ;
6135
6136 if (!args) SWIG_fail;
6137 swig_obj[0] = args;
6138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6139 if (!SWIG_IsOK(res1)) {
6140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6141 }
6142 arg1 = reinterpret_cast< wxPoint * >(argp1);
6143 {
6144 PyThreadState* __tstate = wxPyBeginAllowThreads();
6145 result = (PyObject *)wxPoint_Get(arg1);
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 resultobj = result;
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6157 PyObject *obj;
6158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6160 return SWIG_Py_Void();
6161 }
6162
6163 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6164 return SWIG_Python_InitShadowInstance(args);
6165 }
6166
6167 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 int arg1 = (int) 0 ;
6170 int arg2 = (int) 0 ;
6171 int arg3 = (int) 0 ;
6172 int arg4 = (int) 0 ;
6173 wxRect *result = 0 ;
6174 int val1 ;
6175 int ecode1 = 0 ;
6176 int val2 ;
6177 int ecode2 = 0 ;
6178 int val3 ;
6179 int ecode3 = 0 ;
6180 int val4 ;
6181 int ecode4 = 0 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 PyObject * obj2 = 0 ;
6185 PyObject * obj3 = 0 ;
6186 char * kwnames[] = {
6187 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6188 };
6189
6190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6191 if (obj0) {
6192 ecode1 = SWIG_AsVal_int(obj0, &val1);
6193 if (!SWIG_IsOK(ecode1)) {
6194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6195 }
6196 arg1 = static_cast< int >(val1);
6197 }
6198 if (obj1) {
6199 ecode2 = SWIG_AsVal_int(obj1, &val2);
6200 if (!SWIG_IsOK(ecode2)) {
6201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6202 }
6203 arg2 = static_cast< int >(val2);
6204 }
6205 if (obj2) {
6206 ecode3 = SWIG_AsVal_int(obj2, &val3);
6207 if (!SWIG_IsOK(ecode3)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6209 }
6210 arg3 = static_cast< int >(val3);
6211 }
6212 if (obj3) {
6213 ecode4 = SWIG_AsVal_int(obj3, &val4);
6214 if (!SWIG_IsOK(ecode4)) {
6215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6216 }
6217 arg4 = static_cast< int >(val4);
6218 }
6219 {
6220 PyThreadState* __tstate = wxPyBeginAllowThreads();
6221 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6222 wxPyEndAllowThreads(__tstate);
6223 if (PyErr_Occurred()) SWIG_fail;
6224 }
6225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6226 return resultobj;
6227 fail:
6228 return NULL;
6229 }
6230
6231
6232 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6233 PyObject *resultobj = 0;
6234 wxPoint *arg1 = 0 ;
6235 wxPoint *arg2 = 0 ;
6236 wxRect *result = 0 ;
6237 wxPoint temp1 ;
6238 wxPoint temp2 ;
6239 PyObject * obj0 = 0 ;
6240 PyObject * obj1 = 0 ;
6241 char * kwnames[] = {
6242 (char *) "topLeft",(char *) "bottomRight", NULL
6243 };
6244
6245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6246 {
6247 arg1 = &temp1;
6248 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6249 }
6250 {
6251 arg2 = &temp2;
6252 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6253 }
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6257 wxPyEndAllowThreads(__tstate);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6268 PyObject *resultobj = 0;
6269 wxPoint *arg1 = 0 ;
6270 wxSize *arg2 = 0 ;
6271 wxRect *result = 0 ;
6272 wxPoint temp1 ;
6273 wxSize temp2 ;
6274 PyObject * obj0 = 0 ;
6275 PyObject * obj1 = 0 ;
6276 char * kwnames[] = {
6277 (char *) "pos",(char *) "size", NULL
6278 };
6279
6280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6281 {
6282 arg1 = &temp1;
6283 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6284 }
6285 {
6286 arg2 = &temp2;
6287 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6288 }
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6292 wxPyEndAllowThreads(__tstate);
6293 if (PyErr_Occurred()) SWIG_fail;
6294 }
6295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6296 return resultobj;
6297 fail:
6298 return NULL;
6299 }
6300
6301
6302 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6303 PyObject *resultobj = 0;
6304 wxSize *arg1 = 0 ;
6305 wxRect *result = 0 ;
6306 wxSize temp1 ;
6307 PyObject * obj0 = 0 ;
6308 char * kwnames[] = {
6309 (char *) "size", NULL
6310 };
6311
6312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6313 {
6314 arg1 = &temp1;
6315 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6316 }
6317 {
6318 PyThreadState* __tstate = wxPyBeginAllowThreads();
6319 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6320 wxPyEndAllowThreads(__tstate);
6321 if (PyErr_Occurred()) SWIG_fail;
6322 }
6323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6324 return resultobj;
6325 fail:
6326 return NULL;
6327 }
6328
6329
6330 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6331 PyObject *resultobj = 0;
6332 wxRect *arg1 = (wxRect *) 0 ;
6333 void *argp1 = 0 ;
6334 int res1 = 0 ;
6335 PyObject *swig_obj[1] ;
6336
6337 if (!args) SWIG_fail;
6338 swig_obj[0] = args;
6339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 delete arg1;
6347
6348 wxPyEndAllowThreads(__tstate);
6349 if (PyErr_Occurred()) SWIG_fail;
6350 }
6351 resultobj = SWIG_Py_Void();
6352 return resultobj;
6353 fail:
6354 return NULL;
6355 }
6356
6357
6358 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6359 PyObject *resultobj = 0;
6360 wxRect *arg1 = (wxRect *) 0 ;
6361 int result;
6362 void *argp1 = 0 ;
6363 int res1 = 0 ;
6364 PyObject *swig_obj[1] ;
6365
6366 if (!args) SWIG_fail;
6367 swig_obj[0] = args;
6368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6369 if (!SWIG_IsOK(res1)) {
6370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6371 }
6372 arg1 = reinterpret_cast< wxRect * >(argp1);
6373 {
6374 PyThreadState* __tstate = wxPyBeginAllowThreads();
6375 result = (int)((wxRect const *)arg1)->GetX();
6376 wxPyEndAllowThreads(__tstate);
6377 if (PyErr_Occurred()) SWIG_fail;
6378 }
6379 resultobj = SWIG_From_int(static_cast< int >(result));
6380 return resultobj;
6381 fail:
6382 return NULL;
6383 }
6384
6385
6386 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6387 PyObject *resultobj = 0;
6388 wxRect *arg1 = (wxRect *) 0 ;
6389 int arg2 ;
6390 void *argp1 = 0 ;
6391 int res1 = 0 ;
6392 int val2 ;
6393 int ecode2 = 0 ;
6394 PyObject * obj0 = 0 ;
6395 PyObject * obj1 = 0 ;
6396 char * kwnames[] = {
6397 (char *) "self",(char *) "x", NULL
6398 };
6399
6400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6402 if (!SWIG_IsOK(res1)) {
6403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6404 }
6405 arg1 = reinterpret_cast< wxRect * >(argp1);
6406 ecode2 = SWIG_AsVal_int(obj1, &val2);
6407 if (!SWIG_IsOK(ecode2)) {
6408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6409 }
6410 arg2 = static_cast< int >(val2);
6411 {
6412 PyThreadState* __tstate = wxPyBeginAllowThreads();
6413 (arg1)->SetX(arg2);
6414 wxPyEndAllowThreads(__tstate);
6415 if (PyErr_Occurred()) SWIG_fail;
6416 }
6417 resultobj = SWIG_Py_Void();
6418 return resultobj;
6419 fail:
6420 return NULL;
6421 }
6422
6423
6424 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6425 PyObject *resultobj = 0;
6426 wxRect *arg1 = (wxRect *) 0 ;
6427 int result;
6428 void *argp1 = 0 ;
6429 int res1 = 0 ;
6430 PyObject *swig_obj[1] ;
6431
6432 if (!args) SWIG_fail;
6433 swig_obj[0] = args;
6434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6435 if (!SWIG_IsOK(res1)) {
6436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6437 }
6438 arg1 = reinterpret_cast< wxRect * >(argp1);
6439 {
6440 PyThreadState* __tstate = wxPyBeginAllowThreads();
6441 result = (int)(arg1)->GetY();
6442 wxPyEndAllowThreads(__tstate);
6443 if (PyErr_Occurred()) SWIG_fail;
6444 }
6445 resultobj = SWIG_From_int(static_cast< int >(result));
6446 return resultobj;
6447 fail:
6448 return NULL;
6449 }
6450
6451
6452 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6453 PyObject *resultobj = 0;
6454 wxRect *arg1 = (wxRect *) 0 ;
6455 int arg2 ;
6456 void *argp1 = 0 ;
6457 int res1 = 0 ;
6458 int val2 ;
6459 int ecode2 = 0 ;
6460 PyObject * obj0 = 0 ;
6461 PyObject * obj1 = 0 ;
6462 char * kwnames[] = {
6463 (char *) "self",(char *) "y", NULL
6464 };
6465
6466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6470 }
6471 arg1 = reinterpret_cast< wxRect * >(argp1);
6472 ecode2 = SWIG_AsVal_int(obj1, &val2);
6473 if (!SWIG_IsOK(ecode2)) {
6474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6475 }
6476 arg2 = static_cast< int >(val2);
6477 {
6478 PyThreadState* __tstate = wxPyBeginAllowThreads();
6479 (arg1)->SetY(arg2);
6480 wxPyEndAllowThreads(__tstate);
6481 if (PyErr_Occurred()) SWIG_fail;
6482 }
6483 resultobj = SWIG_Py_Void();
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6491 PyObject *resultobj = 0;
6492 wxRect *arg1 = (wxRect *) 0 ;
6493 int result;
6494 void *argp1 = 0 ;
6495 int res1 = 0 ;
6496 PyObject *swig_obj[1] ;
6497
6498 if (!args) SWIG_fail;
6499 swig_obj[0] = args;
6500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6501 if (!SWIG_IsOK(res1)) {
6502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6503 }
6504 arg1 = reinterpret_cast< wxRect * >(argp1);
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (int)((wxRect const *)arg1)->GetWidth();
6508 wxPyEndAllowThreads(__tstate);
6509 if (PyErr_Occurred()) SWIG_fail;
6510 }
6511 resultobj = SWIG_From_int(static_cast< int >(result));
6512 return resultobj;
6513 fail:
6514 return NULL;
6515 }
6516
6517
6518 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6519 PyObject *resultobj = 0;
6520 wxRect *arg1 = (wxRect *) 0 ;
6521 int arg2 ;
6522 void *argp1 = 0 ;
6523 int res1 = 0 ;
6524 int val2 ;
6525 int ecode2 = 0 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 char * kwnames[] = {
6529 (char *) "self",(char *) "w", NULL
6530 };
6531
6532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 ecode2 = SWIG_AsVal_int(obj1, &val2);
6539 if (!SWIG_IsOK(ecode2)) {
6540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6541 }
6542 arg2 = static_cast< int >(val2);
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 (arg1)->SetWidth(arg2);
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 resultobj = SWIG_Py_Void();
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6557 PyObject *resultobj = 0;
6558 wxRect *arg1 = (wxRect *) 0 ;
6559 int result;
6560 void *argp1 = 0 ;
6561 int res1 = 0 ;
6562 PyObject *swig_obj[1] ;
6563
6564 if (!args) SWIG_fail;
6565 swig_obj[0] = args;
6566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6567 if (!SWIG_IsOK(res1)) {
6568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6569 }
6570 arg1 = reinterpret_cast< wxRect * >(argp1);
6571 {
6572 PyThreadState* __tstate = wxPyBeginAllowThreads();
6573 result = (int)((wxRect const *)arg1)->GetHeight();
6574 wxPyEndAllowThreads(__tstate);
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj = 0;
6586 wxRect *arg1 = (wxRect *) 0 ;
6587 int arg2 ;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 int val2 ;
6591 int ecode2 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 char * kwnames[] = {
6595 (char *) "self",(char *) "h", NULL
6596 };
6597
6598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 ecode2 = SWIG_AsVal_int(obj1, &val2);
6605 if (!SWIG_IsOK(ecode2)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6607 }
6608 arg2 = static_cast< int >(val2);
6609 {
6610 PyThreadState* __tstate = wxPyBeginAllowThreads();
6611 (arg1)->SetHeight(arg2);
6612 wxPyEndAllowThreads(__tstate);
6613 if (PyErr_Occurred()) SWIG_fail;
6614 }
6615 resultobj = SWIG_Py_Void();
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6623 PyObject *resultobj = 0;
6624 wxRect *arg1 = (wxRect *) 0 ;
6625 wxPoint result;
6626 void *argp1 = 0 ;
6627 int res1 = 0 ;
6628 PyObject *swig_obj[1] ;
6629
6630 if (!args) SWIG_fail;
6631 swig_obj[0] = args;
6632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = ((wxRect const *)arg1)->GetPosition();
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 wxPoint *arg2 = 0 ;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 wxPoint temp2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char * kwnames[] = {
6660 (char *) "self",(char *) "p", NULL
6661 };
6662
6663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 arg2 = &temp2;
6671 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6672 }
6673 {
6674 PyThreadState* __tstate = wxPyBeginAllowThreads();
6675 (arg1)->SetPosition((wxPoint const &)*arg2);
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 resultobj = SWIG_Py_Void();
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6687 PyObject *resultobj = 0;
6688 wxRect *arg1 = (wxRect *) 0 ;
6689 wxSize result;
6690 void *argp1 = 0 ;
6691 int res1 = 0 ;
6692 PyObject *swig_obj[1] ;
6693
6694 if (!args) SWIG_fail;
6695 swig_obj[0] = args;
6696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 result = ((wxRect const *)arg1)->GetSize();
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj = 0;
6716 wxRect *arg1 = (wxRect *) 0 ;
6717 wxSize *arg2 = 0 ;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 wxSize temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char * kwnames[] = {
6724 (char *) "self",(char *) "s", NULL
6725 };
6726
6727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6729 if (!SWIG_IsOK(res1)) {
6730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6731 }
6732 arg1 = reinterpret_cast< wxRect * >(argp1);
6733 {
6734 arg2 = &temp2;
6735 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6736 }
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 (arg1)->SetSize((wxSize const &)*arg2);
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_Py_Void();
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 wxRect *arg1 = (wxRect *) 0 ;
6753 bool result;
6754 void *argp1 = 0 ;
6755 int res1 = 0 ;
6756 PyObject *swig_obj[1] ;
6757
6758 if (!args) SWIG_fail;
6759 swig_obj[0] = args;
6760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6763 }
6764 arg1 = reinterpret_cast< wxRect * >(argp1);
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (bool)((wxRect const *)arg1)->IsEmpty();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 {
6772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6773 }
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxPoint result;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 PyObject *swig_obj[1] ;
6787
6788 if (!args) SWIG_fail;
6789 swig_obj[0] = args;
6790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 result = ((wxRect const *)arg1)->GetTopLeft();
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6809 PyObject *resultobj = 0;
6810 wxRect *arg1 = (wxRect *) 0 ;
6811 wxPoint *arg2 = 0 ;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 wxPoint temp2 ;
6815 PyObject * obj0 = 0 ;
6816 PyObject * obj1 = 0 ;
6817 char * kwnames[] = {
6818 (char *) "self",(char *) "p", NULL
6819 };
6820
6821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 arg2 = &temp2;
6829 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6830 }
6831 {
6832 PyThreadState* __tstate = wxPyBeginAllowThreads();
6833 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6834 wxPyEndAllowThreads(__tstate);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 PyThreadState* __tstate = wxPyBeginAllowThreads();
6861 result = ((wxRect const *)arg1)->GetBottomRight();
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6866 return resultobj;
6867 fail:
6868 return NULL;
6869 }
6870
6871
6872 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6873 PyObject *resultobj = 0;
6874 wxRect *arg1 = (wxRect *) 0 ;
6875 wxPoint *arg2 = 0 ;
6876 void *argp1 = 0 ;
6877 int res1 = 0 ;
6878 wxPoint temp2 ;
6879 PyObject * obj0 = 0 ;
6880 PyObject * obj1 = 0 ;
6881 char * kwnames[] = {
6882 (char *) "self",(char *) "p", NULL
6883 };
6884
6885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6887 if (!SWIG_IsOK(res1)) {
6888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6889 }
6890 arg1 = reinterpret_cast< wxRect * >(argp1);
6891 {
6892 arg2 = &temp2;
6893 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6894 }
6895 {
6896 PyThreadState* __tstate = wxPyBeginAllowThreads();
6897 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 resultobj = SWIG_Py_Void();
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6909 PyObject *resultobj = 0;
6910 wxRect *arg1 = (wxRect *) 0 ;
6911 wxPoint result;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 PyObject *swig_obj[1] ;
6915
6916 if (!args) SWIG_fail;
6917 swig_obj[0] = args;
6918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6919 if (!SWIG_IsOK(res1)) {
6920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6921 }
6922 arg1 = reinterpret_cast< wxRect * >(argp1);
6923 {
6924 PyThreadState* __tstate = wxPyBeginAllowThreads();
6925 result = ((wxRect const *)arg1)->GetTopRight();
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6937 PyObject *resultobj = 0;
6938 wxRect *arg1 = (wxRect *) 0 ;
6939 wxPoint *arg2 = 0 ;
6940 void *argp1 = 0 ;
6941 int res1 = 0 ;
6942 wxPoint temp2 ;
6943 PyObject * obj0 = 0 ;
6944 PyObject * obj1 = 0 ;
6945 char * kwnames[] = {
6946 (char *) "self",(char *) "p", NULL
6947 };
6948
6949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 {
6956 arg2 = &temp2;
6957 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6958 }
6959 {
6960 PyThreadState* __tstate = wxPyBeginAllowThreads();
6961 (arg1)->SetTopRight((wxPoint const &)*arg2);
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_Py_Void();
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6973 PyObject *resultobj = 0;
6974 wxRect *arg1 = (wxRect *) 0 ;
6975 wxPoint result;
6976 void *argp1 = 0 ;
6977 int res1 = 0 ;
6978 PyObject *swig_obj[1] ;
6979
6980 if (!args) SWIG_fail;
6981 swig_obj[0] = args;
6982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6983 if (!SWIG_IsOK(res1)) {
6984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6985 }
6986 arg1 = reinterpret_cast< wxRect * >(argp1);
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 result = ((wxRect const *)arg1)->GetBottomLeft();
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 wxPoint *arg2 = 0 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 wxPoint temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char * kwnames[] = {
7010 (char *) "self",(char *) "p", NULL
7011 };
7012
7013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7015 if (!SWIG_IsOK(res1)) {
7016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7017 }
7018 arg1 = reinterpret_cast< wxRect * >(argp1);
7019 {
7020 arg2 = &temp2;
7021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7022 }
7023 {
7024 PyThreadState* __tstate = wxPyBeginAllowThreads();
7025 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7026 wxPyEndAllowThreads(__tstate);
7027 if (PyErr_Occurred()) SWIG_fail;
7028 }
7029 resultobj = SWIG_Py_Void();
7030 return resultobj;
7031 fail:
7032 return NULL;
7033 }
7034
7035
7036 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7037 PyObject *resultobj = 0;
7038 wxRect *arg1 = (wxRect *) 0 ;
7039 int result;
7040 void *argp1 = 0 ;
7041 int res1 = 0 ;
7042 PyObject *swig_obj[1] ;
7043
7044 if (!args) SWIG_fail;
7045 swig_obj[0] = args;
7046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7047 if (!SWIG_IsOK(res1)) {
7048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7049 }
7050 arg1 = reinterpret_cast< wxRect * >(argp1);
7051 {
7052 PyThreadState* __tstate = wxPyBeginAllowThreads();
7053 result = (int)((wxRect const *)arg1)->GetLeft();
7054 wxPyEndAllowThreads(__tstate);
7055 if (PyErr_Occurred()) SWIG_fail;
7056 }
7057 resultobj = SWIG_From_int(static_cast< int >(result));
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7065 PyObject *resultobj = 0;
7066 wxRect *arg1 = (wxRect *) 0 ;
7067 int result;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 PyObject *swig_obj[1] ;
7071
7072 if (!args) SWIG_fail;
7073 swig_obj[0] = args;
7074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7075 if (!SWIG_IsOK(res1)) {
7076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7077 }
7078 arg1 = reinterpret_cast< wxRect * >(argp1);
7079 {
7080 PyThreadState* __tstate = wxPyBeginAllowThreads();
7081 result = (int)((wxRect const *)arg1)->GetTop();
7082 wxPyEndAllowThreads(__tstate);
7083 if (PyErr_Occurred()) SWIG_fail;
7084 }
7085 resultobj = SWIG_From_int(static_cast< int >(result));
7086 return resultobj;
7087 fail:
7088 return NULL;
7089 }
7090
7091
7092 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7093 PyObject *resultobj = 0;
7094 wxRect *arg1 = (wxRect *) 0 ;
7095 int result;
7096 void *argp1 = 0 ;
7097 int res1 = 0 ;
7098 PyObject *swig_obj[1] ;
7099
7100 if (!args) SWIG_fail;
7101 swig_obj[0] = args;
7102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7103 if (!SWIG_IsOK(res1)) {
7104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7105 }
7106 arg1 = reinterpret_cast< wxRect * >(argp1);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 result = (int)((wxRect const *)arg1)->GetBottom();
7110 wxPyEndAllowThreads(__tstate);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 resultobj = SWIG_From_int(static_cast< int >(result));
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7121 PyObject *resultobj = 0;
7122 wxRect *arg1 = (wxRect *) 0 ;
7123 int result;
7124 void *argp1 = 0 ;
7125 int res1 = 0 ;
7126 PyObject *swig_obj[1] ;
7127
7128 if (!args) SWIG_fail;
7129 swig_obj[0] = args;
7130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7131 if (!SWIG_IsOK(res1)) {
7132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7133 }
7134 arg1 = reinterpret_cast< wxRect * >(argp1);
7135 {
7136 PyThreadState* __tstate = wxPyBeginAllowThreads();
7137 result = (int)((wxRect const *)arg1)->GetRight();
7138 wxPyEndAllowThreads(__tstate);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_From_int(static_cast< int >(result));
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 int arg2 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 int val2 ;
7155 int ecode2 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "left", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 {
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 (arg1)->SetLeft(arg2);
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 resultobj = SWIG_Py_Void();
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = 0;
7188 wxRect *arg1 = (wxRect *) 0 ;
7189 int arg2 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 int val2 ;
7193 int ecode2 = 0 ;
7194 PyObject * obj0 = 0 ;
7195 PyObject * obj1 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "self",(char *) "right", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7202 if (!SWIG_IsOK(res1)) {
7203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7204 }
7205 arg1 = reinterpret_cast< wxRect * >(argp1);
7206 ecode2 = SWIG_AsVal_int(obj1, &val2);
7207 if (!SWIG_IsOK(ecode2)) {
7208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7209 }
7210 arg2 = static_cast< int >(val2);
7211 {
7212 PyThreadState* __tstate = wxPyBeginAllowThreads();
7213 (arg1)->SetRight(arg2);
7214 wxPyEndAllowThreads(__tstate);
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_Py_Void();
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj = 0;
7226 wxRect *arg1 = (wxRect *) 0 ;
7227 int arg2 ;
7228 void *argp1 = 0 ;
7229 int res1 = 0 ;
7230 int val2 ;
7231 int ecode2 = 0 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "top", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 ecode2 = SWIG_AsVal_int(obj1, &val2);
7245 if (!SWIG_IsOK(ecode2)) {
7246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7247 }
7248 arg2 = static_cast< int >(val2);
7249 {
7250 PyThreadState* __tstate = wxPyBeginAllowThreads();
7251 (arg1)->SetTop(arg2);
7252 wxPyEndAllowThreads(__tstate);
7253 if (PyErr_Occurred()) SWIG_fail;
7254 }
7255 resultobj = SWIG_Py_Void();
7256 return resultobj;
7257 fail:
7258 return NULL;
7259 }
7260
7261
7262 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj = 0;
7264 wxRect *arg1 = (wxRect *) 0 ;
7265 int arg2 ;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 int val2 ;
7269 int ecode2 = 0 ;
7270 PyObject * obj0 = 0 ;
7271 PyObject * obj1 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "bottom", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 ecode2 = SWIG_AsVal_int(obj1, &val2);
7283 if (!SWIG_IsOK(ecode2)) {
7284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7285 }
7286 arg2 = static_cast< int >(val2);
7287 {
7288 PyThreadState* __tstate = wxPyBeginAllowThreads();
7289 (arg1)->SetBottom(arg2);
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 resultobj = SWIG_Py_Void();
7294 return resultobj;
7295 fail:
7296 return NULL;
7297 }
7298
7299
7300 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj = 0;
7302 wxRect *arg1 = (wxRect *) 0 ;
7303 int arg2 ;
7304 int arg3 ;
7305 wxRect *result = 0 ;
7306 void *argp1 = 0 ;
7307 int res1 = 0 ;
7308 int val2 ;
7309 int ecode2 = 0 ;
7310 int val3 ;
7311 int ecode3 = 0 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 PyObject * obj2 = 0 ;
7315 char * kwnames[] = {
7316 (char *) "self",(char *) "dx",(char *) "dy", NULL
7317 };
7318
7319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7321 if (!SWIG_IsOK(res1)) {
7322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7323 }
7324 arg1 = reinterpret_cast< wxRect * >(argp1);
7325 ecode2 = SWIG_AsVal_int(obj1, &val2);
7326 if (!SWIG_IsOK(ecode2)) {
7327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7328 }
7329 arg2 = static_cast< int >(val2);
7330 ecode3 = SWIG_AsVal_int(obj2, &val3);
7331 if (!SWIG_IsOK(ecode3)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7333 }
7334 arg3 = static_cast< int >(val3);
7335 {
7336 PyThreadState* __tstate = wxPyBeginAllowThreads();
7337 {
7338 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7339 result = (wxRect *) &_result_ref;
7340 }
7341 wxPyEndAllowThreads(__tstate);
7342 if (PyErr_Occurred()) SWIG_fail;
7343 }
7344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = 0;
7353 wxRect *arg1 = (wxRect *) 0 ;
7354 int arg2 ;
7355 int arg3 ;
7356 wxRect *result = 0 ;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 int val2 ;
7360 int ecode2 = 0 ;
7361 int val3 ;
7362 int ecode3 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 PyObject * obj2 = 0 ;
7366 char * kwnames[] = {
7367 (char *) "self",(char *) "dx",(char *) "dy", NULL
7368 };
7369
7370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7372 if (!SWIG_IsOK(res1)) {
7373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7374 }
7375 arg1 = reinterpret_cast< wxRect * >(argp1);
7376 ecode2 = SWIG_AsVal_int(obj1, &val2);
7377 if (!SWIG_IsOK(ecode2)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7379 }
7380 arg2 = static_cast< int >(val2);
7381 ecode3 = SWIG_AsVal_int(obj2, &val3);
7382 if (!SWIG_IsOK(ecode3)) {
7383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7384 }
7385 arg3 = static_cast< int >(val3);
7386 {
7387 PyThreadState* __tstate = wxPyBeginAllowThreads();
7388 {
7389 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7390 result = (wxRect *) &_result_ref;
7391 }
7392 wxPyEndAllowThreads(__tstate);
7393 if (PyErr_Occurred()) SWIG_fail;
7394 }
7395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7396 return resultobj;
7397 fail:
7398 return NULL;
7399 }
7400
7401
7402 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7403 PyObject *resultobj = 0;
7404 wxRect *arg1 = (wxRect *) 0 ;
7405 int arg2 ;
7406 int arg3 ;
7407 void *argp1 = 0 ;
7408 int res1 = 0 ;
7409 int val2 ;
7410 int ecode2 = 0 ;
7411 int val3 ;
7412 int ecode3 = 0 ;
7413 PyObject * obj0 = 0 ;
7414 PyObject * obj1 = 0 ;
7415 PyObject * obj2 = 0 ;
7416 char * kwnames[] = {
7417 (char *) "self",(char *) "dx",(char *) "dy", NULL
7418 };
7419
7420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7422 if (!SWIG_IsOK(res1)) {
7423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7424 }
7425 arg1 = reinterpret_cast< wxRect * >(argp1);
7426 ecode2 = SWIG_AsVal_int(obj1, &val2);
7427 if (!SWIG_IsOK(ecode2)) {
7428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7429 }
7430 arg2 = static_cast< int >(val2);
7431 ecode3 = SWIG_AsVal_int(obj2, &val3);
7432 if (!SWIG_IsOK(ecode3)) {
7433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7434 }
7435 arg3 = static_cast< int >(val3);
7436 {
7437 PyThreadState* __tstate = wxPyBeginAllowThreads();
7438 (arg1)->Offset(arg2,arg3);
7439 wxPyEndAllowThreads(__tstate);
7440 if (PyErr_Occurred()) SWIG_fail;
7441 }
7442 resultobj = SWIG_Py_Void();
7443 return resultobj;
7444 fail:
7445 return NULL;
7446 }
7447
7448
7449 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7450 PyObject *resultobj = 0;
7451 wxRect *arg1 = (wxRect *) 0 ;
7452 wxPoint *arg2 = 0 ;
7453 void *argp1 = 0 ;
7454 int res1 = 0 ;
7455 wxPoint temp2 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char * kwnames[] = {
7459 (char *) "self",(char *) "pt", NULL
7460 };
7461
7462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7464 if (!SWIG_IsOK(res1)) {
7465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7466 }
7467 arg1 = reinterpret_cast< wxRect * >(argp1);
7468 {
7469 arg2 = &temp2;
7470 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->Offset((wxPoint const &)*arg2);
7475 wxPyEndAllowThreads(__tstate);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 resultobj = SWIG_Py_Void();
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxRect *arg1 = (wxRect *) 0 ;
7488 wxRect *arg2 = 0 ;
7489 wxRect result;
7490 void *argp1 = 0 ;
7491 int res1 = 0 ;
7492 wxRect temp2 ;
7493 PyObject * obj0 = 0 ;
7494 PyObject * obj1 = 0 ;
7495 char * kwnames[] = {
7496 (char *) "self",(char *) "rect", NULL
7497 };
7498
7499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7501 if (!SWIG_IsOK(res1)) {
7502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7503 }
7504 arg1 = reinterpret_cast< wxRect * >(argp1);
7505 {
7506 arg2 = &temp2;
7507 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7508 }
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (arg1)->Intersect((wxRect const &)*arg2);
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj = 0;
7524 wxRect *arg1 = (wxRect *) 0 ;
7525 wxRect *arg2 = 0 ;
7526 wxRect result;
7527 void *argp1 = 0 ;
7528 int res1 = 0 ;
7529 wxRect temp2 ;
7530 PyObject * obj0 = 0 ;
7531 PyObject * obj1 = 0 ;
7532 char * kwnames[] = {
7533 (char *) "self",(char *) "rect", NULL
7534 };
7535
7536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7538 if (!SWIG_IsOK(res1)) {
7539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7540 }
7541 arg1 = reinterpret_cast< wxRect * >(argp1);
7542 {
7543 arg2 = &temp2;
7544 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7545 }
7546 {
7547 PyThreadState* __tstate = wxPyBeginAllowThreads();
7548 result = (arg1)->Union((wxRect const &)*arg2);
7549 wxPyEndAllowThreads(__tstate);
7550 if (PyErr_Occurred()) SWIG_fail;
7551 }
7552 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7553 return resultobj;
7554 fail:
7555 return NULL;
7556 }
7557
7558
7559 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7560 PyObject *resultobj = 0;
7561 wxRect *arg1 = (wxRect *) 0 ;
7562 wxRect *arg2 = 0 ;
7563 wxRect result;
7564 void *argp1 = 0 ;
7565 int res1 = 0 ;
7566 wxRect temp2 ;
7567 PyObject * obj0 = 0 ;
7568 PyObject * obj1 = 0 ;
7569 char * kwnames[] = {
7570 (char *) "self",(char *) "rect", NULL
7571 };
7572
7573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7575 if (!SWIG_IsOK(res1)) {
7576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7577 }
7578 arg1 = reinterpret_cast< wxRect * >(argp1);
7579 {
7580 arg2 = &temp2;
7581 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7582 }
7583 {
7584 PyThreadState* __tstate = wxPyBeginAllowThreads();
7585 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7586 wxPyEndAllowThreads(__tstate);
7587 if (PyErr_Occurred()) SWIG_fail;
7588 }
7589 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7590 return resultobj;
7591 fail:
7592 return NULL;
7593 }
7594
7595
7596 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7597 PyObject *resultobj = 0;
7598 wxRect *arg1 = (wxRect *) 0 ;
7599 wxRect *arg2 = 0 ;
7600 wxRect *result = 0 ;
7601 void *argp1 = 0 ;
7602 int res1 = 0 ;
7603 wxRect temp2 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 char * kwnames[] = {
7607 (char *) "self",(char *) "rect", NULL
7608 };
7609
7610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7612 if (!SWIG_IsOK(res1)) {
7613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7614 }
7615 arg1 = reinterpret_cast< wxRect * >(argp1);
7616 {
7617 arg2 = &temp2;
7618 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7619 }
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 {
7623 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7624 result = (wxRect *) &_result_ref;
7625 }
7626 wxPyEndAllowThreads(__tstate);
7627 if (PyErr_Occurred()) SWIG_fail;
7628 }
7629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7637 PyObject *resultobj = 0;
7638 wxRect *arg1 = (wxRect *) 0 ;
7639 PyObject *arg2 = (PyObject *) 0 ;
7640 bool result;
7641 void *argp1 = 0 ;
7642 int res1 = 0 ;
7643 PyObject * obj0 = 0 ;
7644 PyObject * obj1 = 0 ;
7645 char * kwnames[] = {
7646 (char *) "self",(char *) "other", NULL
7647 };
7648
7649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7651 if (!SWIG_IsOK(res1)) {
7652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7653 }
7654 arg1 = reinterpret_cast< wxRect * >(argp1);
7655 arg2 = obj1;
7656 {
7657 result = (bool)wxRect___eq__(arg1,arg2);
7658 if (PyErr_Occurred()) SWIG_fail;
7659 }
7660 {
7661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7662 }
7663 return resultobj;
7664 fail:
7665 return NULL;
7666 }
7667
7668
7669 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7670 PyObject *resultobj = 0;
7671 wxRect *arg1 = (wxRect *) 0 ;
7672 PyObject *arg2 = (PyObject *) 0 ;
7673 bool result;
7674 void *argp1 = 0 ;
7675 int res1 = 0 ;
7676 PyObject * obj0 = 0 ;
7677 PyObject * obj1 = 0 ;
7678 char * kwnames[] = {
7679 (char *) "self",(char *) "other", NULL
7680 };
7681
7682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7684 if (!SWIG_IsOK(res1)) {
7685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7686 }
7687 arg1 = reinterpret_cast< wxRect * >(argp1);
7688 arg2 = obj1;
7689 {
7690 result = (bool)wxRect___ne__(arg1,arg2);
7691 if (PyErr_Occurred()) SWIG_fail;
7692 }
7693 {
7694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7695 }
7696 return resultobj;
7697 fail:
7698 return NULL;
7699 }
7700
7701
7702 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7703 PyObject *resultobj = 0;
7704 wxRect *arg1 = (wxRect *) 0 ;
7705 int arg2 ;
7706 int arg3 ;
7707 bool result;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 int val2 ;
7711 int ecode2 = 0 ;
7712 int val3 ;
7713 int ecode3 = 0 ;
7714 PyObject * obj0 = 0 ;
7715 PyObject * obj1 = 0 ;
7716 PyObject * obj2 = 0 ;
7717 char * kwnames[] = {
7718 (char *) "self",(char *) "x",(char *) "y", NULL
7719 };
7720
7721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7723 if (!SWIG_IsOK(res1)) {
7724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7725 }
7726 arg1 = reinterpret_cast< wxRect * >(argp1);
7727 ecode2 = SWIG_AsVal_int(obj1, &val2);
7728 if (!SWIG_IsOK(ecode2)) {
7729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7730 }
7731 arg2 = static_cast< int >(val2);
7732 ecode3 = SWIG_AsVal_int(obj2, &val3);
7733 if (!SWIG_IsOK(ecode3)) {
7734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7735 }
7736 arg3 = static_cast< int >(val3);
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 {
7744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7745 }
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 wxPoint *arg2 = 0 ;
7756 bool result;
7757 void *argp1 = 0 ;
7758 int res1 = 0 ;
7759 wxPoint temp2 ;
7760 PyObject * obj0 = 0 ;
7761 PyObject * obj1 = 0 ;
7762 char * kwnames[] = {
7763 (char *) "self",(char *) "pt", NULL
7764 };
7765
7766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7770 }
7771 arg1 = reinterpret_cast< wxRect * >(argp1);
7772 {
7773 arg2 = &temp2;
7774 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7775 }
7776 {
7777 PyThreadState* __tstate = wxPyBeginAllowThreads();
7778 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7779 wxPyEndAllowThreads(__tstate);
7780 if (PyErr_Occurred()) SWIG_fail;
7781 }
7782 {
7783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7784 }
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 wxRect *arg2 = 0 ;
7795 bool result;
7796 void *argp1 = 0 ;
7797 int res1 = 0 ;
7798 wxRect temp2 ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 char * kwnames[] = {
7802 (char *) "self",(char *) "rect", NULL
7803 };
7804
7805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7807 if (!SWIG_IsOK(res1)) {
7808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7809 }
7810 arg1 = reinterpret_cast< wxRect * >(argp1);
7811 {
7812 arg2 = &temp2;
7813 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7814 }
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7818 wxPyEndAllowThreads(__tstate);
7819 if (PyErr_Occurred()) SWIG_fail;
7820 }
7821 {
7822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7823 }
7824 return resultobj;
7825 fail:
7826 return NULL;
7827 }
7828
7829
7830 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7831 PyObject *resultobj = 0;
7832 wxRect *arg1 = (wxRect *) 0 ;
7833 wxRect *arg2 = 0 ;
7834 bool result;
7835 void *argp1 = 0 ;
7836 int res1 = 0 ;
7837 wxRect temp2 ;
7838 PyObject * obj0 = 0 ;
7839 PyObject * obj1 = 0 ;
7840 char * kwnames[] = {
7841 (char *) "self",(char *) "rect", NULL
7842 };
7843
7844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7846 if (!SWIG_IsOK(res1)) {
7847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7848 }
7849 arg1 = reinterpret_cast< wxRect * >(argp1);
7850 {
7851 arg2 = &temp2;
7852 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7853 }
7854 {
7855 PyThreadState* __tstate = wxPyBeginAllowThreads();
7856 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7857 wxPyEndAllowThreads(__tstate);
7858 if (PyErr_Occurred()) SWIG_fail;
7859 }
7860 {
7861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7862 }
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7870 PyObject *resultobj = 0;
7871 wxRect *arg1 = (wxRect *) 0 ;
7872 wxRect *arg2 = 0 ;
7873 int arg3 = (int) wxBOTH ;
7874 wxRect result;
7875 void *argp1 = 0 ;
7876 int res1 = 0 ;
7877 wxRect temp2 ;
7878 int val3 ;
7879 int ecode3 = 0 ;
7880 PyObject * obj0 = 0 ;
7881 PyObject * obj1 = 0 ;
7882 PyObject * obj2 = 0 ;
7883 char * kwnames[] = {
7884 (char *) "self",(char *) "r",(char *) "dir", NULL
7885 };
7886
7887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 {
7894 arg2 = &temp2;
7895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7896 }
7897 if (obj2) {
7898 ecode3 = SWIG_AsVal_int(obj2, &val3);
7899 if (!SWIG_IsOK(ecode3)) {
7900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7901 }
7902 arg3 = static_cast< int >(val3);
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7907 wxPyEndAllowThreads(__tstate);
7908 if (PyErr_Occurred()) SWIG_fail;
7909 }
7910 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7911 return resultobj;
7912 fail:
7913 return NULL;
7914 }
7915
7916
7917 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7918 PyObject *resultobj = 0;
7919 wxRect *arg1 = (wxRect *) 0 ;
7920 int arg2 ;
7921 void *argp1 = 0 ;
7922 int res1 = 0 ;
7923 int val2 ;
7924 int ecode2 = 0 ;
7925 PyObject *swig_obj[2] ;
7926
7927 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7929 if (!SWIG_IsOK(res1)) {
7930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7931 }
7932 arg1 = reinterpret_cast< wxRect * >(argp1);
7933 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7934 if (!SWIG_IsOK(ecode2)) {
7935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7936 }
7937 arg2 = static_cast< int >(val2);
7938 if (arg1) (arg1)->x = arg2;
7939
7940 resultobj = SWIG_Py_Void();
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7948 PyObject *resultobj = 0;
7949 wxRect *arg1 = (wxRect *) 0 ;
7950 int result;
7951 void *argp1 = 0 ;
7952 int res1 = 0 ;
7953 PyObject *swig_obj[1] ;
7954
7955 if (!args) SWIG_fail;
7956 swig_obj[0] = args;
7957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7958 if (!SWIG_IsOK(res1)) {
7959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7960 }
7961 arg1 = reinterpret_cast< wxRect * >(argp1);
7962 result = (int) ((arg1)->x);
7963 resultobj = SWIG_From_int(static_cast< int >(result));
7964 return resultobj;
7965 fail:
7966 return NULL;
7967 }
7968
7969
7970 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7971 PyObject *resultobj = 0;
7972 wxRect *arg1 = (wxRect *) 0 ;
7973 int arg2 ;
7974 void *argp1 = 0 ;
7975 int res1 = 0 ;
7976 int val2 ;
7977 int ecode2 = 0 ;
7978 PyObject *swig_obj[2] ;
7979
7980 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7982 if (!SWIG_IsOK(res1)) {
7983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7984 }
7985 arg1 = reinterpret_cast< wxRect * >(argp1);
7986 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7987 if (!SWIG_IsOK(ecode2)) {
7988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7989 }
7990 arg2 = static_cast< int >(val2);
7991 if (arg1) (arg1)->y = arg2;
7992
7993 resultobj = SWIG_Py_Void();
7994 return resultobj;
7995 fail:
7996 return NULL;
7997 }
7998
7999
8000 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8001 PyObject *resultobj = 0;
8002 wxRect *arg1 = (wxRect *) 0 ;
8003 int result;
8004 void *argp1 = 0 ;
8005 int res1 = 0 ;
8006 PyObject *swig_obj[1] ;
8007
8008 if (!args) SWIG_fail;
8009 swig_obj[0] = args;
8010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8011 if (!SWIG_IsOK(res1)) {
8012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8013 }
8014 arg1 = reinterpret_cast< wxRect * >(argp1);
8015 result = (int) ((arg1)->y);
8016 resultobj = SWIG_From_int(static_cast< int >(result));
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *resultobj = 0;
8025 wxRect *arg1 = (wxRect *) 0 ;
8026 int arg2 ;
8027 void *argp1 = 0 ;
8028 int res1 = 0 ;
8029 int val2 ;
8030 int ecode2 = 0 ;
8031 PyObject *swig_obj[2] ;
8032
8033 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8035 if (!SWIG_IsOK(res1)) {
8036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8037 }
8038 arg1 = reinterpret_cast< wxRect * >(argp1);
8039 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8040 if (!SWIG_IsOK(ecode2)) {
8041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8042 }
8043 arg2 = static_cast< int >(val2);
8044 if (arg1) (arg1)->width = arg2;
8045
8046 resultobj = SWIG_Py_Void();
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055 wxRect *arg1 = (wxRect *) 0 ;
8056 int result;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 PyObject *swig_obj[1] ;
8060
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8066 }
8067 arg1 = reinterpret_cast< wxRect * >(argp1);
8068 result = (int) ((arg1)->width);
8069 resultobj = SWIG_From_int(static_cast< int >(result));
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8077 PyObject *resultobj = 0;
8078 wxRect *arg1 = (wxRect *) 0 ;
8079 int arg2 ;
8080 void *argp1 = 0 ;
8081 int res1 = 0 ;
8082 int val2 ;
8083 int ecode2 = 0 ;
8084 PyObject *swig_obj[2] ;
8085
8086 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8088 if (!SWIG_IsOK(res1)) {
8089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8090 }
8091 arg1 = reinterpret_cast< wxRect * >(argp1);
8092 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8093 if (!SWIG_IsOK(ecode2)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8095 }
8096 arg2 = static_cast< int >(val2);
8097 if (arg1) (arg1)->height = arg2;
8098
8099 resultobj = SWIG_Py_Void();
8100 return resultobj;
8101 fail:
8102 return NULL;
8103 }
8104
8105
8106 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8107 PyObject *resultobj = 0;
8108 wxRect *arg1 = (wxRect *) 0 ;
8109 int result;
8110 void *argp1 = 0 ;
8111 int res1 = 0 ;
8112 PyObject *swig_obj[1] ;
8113
8114 if (!args) SWIG_fail;
8115 swig_obj[0] = args;
8116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8117 if (!SWIG_IsOK(res1)) {
8118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8119 }
8120 arg1 = reinterpret_cast< wxRect * >(argp1);
8121 result = (int) ((arg1)->height);
8122 resultobj = SWIG_From_int(static_cast< int >(result));
8123 return resultobj;
8124 fail:
8125 return NULL;
8126 }
8127
8128
8129 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8130 PyObject *resultobj = 0;
8131 wxRect *arg1 = (wxRect *) 0 ;
8132 int arg2 = (int) 0 ;
8133 int arg3 = (int) 0 ;
8134 int arg4 = (int) 0 ;
8135 int arg5 = (int) 0 ;
8136 void *argp1 = 0 ;
8137 int res1 = 0 ;
8138 int val2 ;
8139 int ecode2 = 0 ;
8140 int val3 ;
8141 int ecode3 = 0 ;
8142 int val4 ;
8143 int ecode4 = 0 ;
8144 int val5 ;
8145 int ecode5 = 0 ;
8146 PyObject * obj0 = 0 ;
8147 PyObject * obj1 = 0 ;
8148 PyObject * obj2 = 0 ;
8149 PyObject * obj3 = 0 ;
8150 PyObject * obj4 = 0 ;
8151 char * kwnames[] = {
8152 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8153 };
8154
8155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 if (obj1) {
8162 ecode2 = SWIG_AsVal_int(obj1, &val2);
8163 if (!SWIG_IsOK(ecode2)) {
8164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8165 }
8166 arg2 = static_cast< int >(val2);
8167 }
8168 if (obj2) {
8169 ecode3 = SWIG_AsVal_int(obj2, &val3);
8170 if (!SWIG_IsOK(ecode3)) {
8171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8172 }
8173 arg3 = static_cast< int >(val3);
8174 }
8175 if (obj3) {
8176 ecode4 = SWIG_AsVal_int(obj3, &val4);
8177 if (!SWIG_IsOK(ecode4)) {
8178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8179 }
8180 arg4 = static_cast< int >(val4);
8181 }
8182 if (obj4) {
8183 ecode5 = SWIG_AsVal_int(obj4, &val5);
8184 if (!SWIG_IsOK(ecode5)) {
8185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8186 }
8187 arg5 = static_cast< int >(val5);
8188 }
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_Py_Void();
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8203 PyObject *resultobj = 0;
8204 wxRect *arg1 = (wxRect *) 0 ;
8205 PyObject *result = 0 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 PyObject *swig_obj[1] ;
8209
8210 if (!args) SWIG_fail;
8211 swig_obj[0] = args;
8212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8213 if (!SWIG_IsOK(res1)) {
8214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8215 }
8216 arg1 = reinterpret_cast< wxRect * >(argp1);
8217 {
8218 PyThreadState* __tstate = wxPyBeginAllowThreads();
8219 result = (PyObject *)wxRect_Get(arg1);
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 resultobj = result;
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8231 PyObject *obj;
8232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8233 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8234 return SWIG_Py_Void();
8235 }
8236
8237 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8238 return SWIG_Python_InitShadowInstance(args);
8239 }
8240
8241 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8242 PyObject *resultobj = 0;
8243 wxRect *arg1 = (wxRect *) 0 ;
8244 wxRect *arg2 = (wxRect *) 0 ;
8245 PyObject *result = 0 ;
8246 void *argp1 = 0 ;
8247 int res1 = 0 ;
8248 void *argp2 = 0 ;
8249 int res2 = 0 ;
8250 PyObject * obj0 = 0 ;
8251 PyObject * obj1 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "r1",(char *) "r2", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8258 if (!SWIG_IsOK(res1)) {
8259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8260 }
8261 arg1 = reinterpret_cast< wxRect * >(argp1);
8262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8263 if (!SWIG_IsOK(res2)) {
8264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8265 }
8266 arg2 = reinterpret_cast< wxRect * >(argp2);
8267 {
8268 if (!wxPyCheckForApp()) SWIG_fail;
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (PyObject *)wxIntersectRect(arg1,arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = result;
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = 0;
8283 double arg1 = (double) 0.0 ;
8284 double arg2 = (double) 0.0 ;
8285 wxPoint2D *result = 0 ;
8286 double val1 ;
8287 int ecode1 = 0 ;
8288 double val2 ;
8289 int ecode2 = 0 ;
8290 PyObject * obj0 = 0 ;
8291 PyObject * obj1 = 0 ;
8292 char * kwnames[] = {
8293 (char *) "x",(char *) "y", NULL
8294 };
8295
8296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8297 if (obj0) {
8298 ecode1 = SWIG_AsVal_double(obj0, &val1);
8299 if (!SWIG_IsOK(ecode1)) {
8300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8301 }
8302 arg1 = static_cast< double >(val1);
8303 }
8304 if (obj1) {
8305 ecode2 = SWIG_AsVal_double(obj1, &val2);
8306 if (!SWIG_IsOK(ecode2)) {
8307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8308 }
8309 arg2 = static_cast< double >(val2);
8310 }
8311 {
8312 PyThreadState* __tstate = wxPyBeginAllowThreads();
8313 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = 0 ;
8327 wxPoint2D *result = 0 ;
8328 wxPoint2D temp1 ;
8329 PyObject * obj0 = 0 ;
8330 char * kwnames[] = {
8331 (char *) "pt", NULL
8332 };
8333
8334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8335 {
8336 arg1 = &temp1;
8337 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 wxPoint *arg1 = 0 ;
8355 wxPoint2D *result = 0 ;
8356 wxPoint temp1 ;
8357 PyObject * obj0 = 0 ;
8358 char * kwnames[] = {
8359 (char *) "pt", NULL
8360 };
8361
8362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8363 {
8364 arg1 = &temp1;
8365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8366 }
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8381 PyObject *resultobj = 0;
8382 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8383 void *argp1 = 0 ;
8384 int res1 = 0 ;
8385 PyObject *swig_obj[1] ;
8386
8387 if (!args) SWIG_fail;
8388 swig_obj[0] = args;
8389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8390 if (!SWIG_IsOK(res1)) {
8391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8392 }
8393 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8394 {
8395 PyThreadState* __tstate = wxPyBeginAllowThreads();
8396 delete arg1;
8397
8398 wxPyEndAllowThreads(__tstate);
8399 if (PyErr_Occurred()) SWIG_fail;
8400 }
8401 resultobj = SWIG_Py_Void();
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8409 PyObject *resultobj = 0;
8410 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8411 int *arg2 = (int *) 0 ;
8412 int *arg3 = (int *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 int temp2 ;
8416 int res2 = SWIG_TMPOBJ ;
8417 int temp3 ;
8418 int res3 = SWIG_TMPOBJ ;
8419 PyObject *swig_obj[1] ;
8420
8421 arg2 = &temp2;
8422 arg3 = &temp3;
8423 if (!args) SWIG_fail;
8424 swig_obj[0] = args;
8425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8426 if (!SWIG_IsOK(res1)) {
8427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8428 }
8429 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8430 {
8431 PyThreadState* __tstate = wxPyBeginAllowThreads();
8432 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8433 wxPyEndAllowThreads(__tstate);
8434 if (PyErr_Occurred()) SWIG_fail;
8435 }
8436 resultobj = SWIG_Py_Void();
8437 if (SWIG_IsTmpObj(res2)) {
8438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8439 } else {
8440 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8442 }
8443 if (SWIG_IsTmpObj(res3)) {
8444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8445 } else {
8446 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8448 }
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8458 int *arg2 = (int *) 0 ;
8459 int *arg3 = (int *) 0 ;
8460 void *argp1 = 0 ;
8461 int res1 = 0 ;
8462 int temp2 ;
8463 int res2 = SWIG_TMPOBJ ;
8464 int temp3 ;
8465 int res3 = SWIG_TMPOBJ ;
8466 PyObject *swig_obj[1] ;
8467
8468 arg2 = &temp2;
8469 arg3 = &temp3;
8470 if (!args) SWIG_fail;
8471 swig_obj[0] = args;
8472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = SWIG_Py_Void();
8484 if (SWIG_IsTmpObj(res2)) {
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8486 } else {
8487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8489 }
8490 if (SWIG_IsTmpObj(res3)) {
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8492 } else {
8493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8505 double result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 resultobj = SWIG_From_double(static_cast< double >(result));
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8533 double result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 PyObject *swig_obj[1] ;
8537
8538 if (!args) SWIG_fail;
8539 swig_obj[0] = args;
8540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_From_double(static_cast< double >(result));
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj = 0;
8560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8561 double arg2 ;
8562 void *argp1 = 0 ;
8563 int res1 = 0 ;
8564 double val2 ;
8565 int ecode2 = 0 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "length", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8576 }
8577 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8578 ecode2 = SWIG_AsVal_double(obj1, &val2);
8579 if (!SWIG_IsOK(ecode2)) {
8580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8581 }
8582 arg2 = static_cast< double >(val2);
8583 {
8584 PyThreadState* __tstate = wxPyBeginAllowThreads();
8585 (arg1)->SetVectorLength(arg2);
8586 wxPyEndAllowThreads(__tstate);
8587 if (PyErr_Occurred()) SWIG_fail;
8588 }
8589 resultobj = SWIG_Py_Void();
8590 return resultobj;
8591 fail:
8592 return NULL;
8593 }
8594
8595
8596 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8597 PyObject *resultobj = 0;
8598 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8599 double arg2 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 double val2 ;
8603 int ecode2 = 0 ;
8604 PyObject * obj0 = 0 ;
8605 PyObject * obj1 = 0 ;
8606 char * kwnames[] = {
8607 (char *) "self",(char *) "degrees", NULL
8608 };
8609
8610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8612 if (!SWIG_IsOK(res1)) {
8613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8614 }
8615 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8616 ecode2 = SWIG_AsVal_double(obj1, &val2);
8617 if (!SWIG_IsOK(ecode2)) {
8618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8619 }
8620 arg2 = static_cast< double >(val2);
8621 {
8622 PyThreadState* __tstate = wxPyBeginAllowThreads();
8623 (arg1)->SetVectorAngle(arg2);
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 resultobj = SWIG_Py_Void();
8628 return resultobj;
8629 fail:
8630 return NULL;
8631 }
8632
8633
8634 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8635 PyObject *resultobj = 0;
8636 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8637 wxPoint2D *arg2 = 0 ;
8638 double result;
8639 void *argp1 = 0 ;
8640 int res1 = 0 ;
8641 wxPoint2D temp2 ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char * kwnames[] = {
8645 (char *) "self",(char *) "pt", NULL
8646 };
8647
8648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8650 if (!SWIG_IsOK(res1)) {
8651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8652 }
8653 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8654 {
8655 arg2 = &temp2;
8656 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8661 wxPyEndAllowThreads(__tstate);
8662 if (PyErr_Occurred()) SWIG_fail;
8663 }
8664 resultobj = SWIG_From_double(static_cast< double >(result));
8665 return resultobj;
8666 fail:
8667 return NULL;
8668 }
8669
8670
8671 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8672 PyObject *resultobj = 0;
8673 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8674 wxPoint2D *arg2 = 0 ;
8675 double result;
8676 void *argp1 = 0 ;
8677 int res1 = 0 ;
8678 wxPoint2D temp2 ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char * kwnames[] = {
8682 (char *) "self",(char *) "pt", NULL
8683 };
8684
8685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8687 if (!SWIG_IsOK(res1)) {
8688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8689 }
8690 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8691 {
8692 arg2 = &temp2;
8693 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8694 }
8695 {
8696 PyThreadState* __tstate = wxPyBeginAllowThreads();
8697 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8698 wxPyEndAllowThreads(__tstate);
8699 if (PyErr_Occurred()) SWIG_fail;
8700 }
8701 resultobj = SWIG_From_double(static_cast< double >(result));
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 wxPoint2D *arg2 = 0 ;
8712 double result;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 wxPoint2D temp2 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 char * kwnames[] = {
8719 (char *) "self",(char *) "vec", NULL
8720 };
8721
8722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 {
8729 arg2 = &temp2;
8730 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8731 }
8732 {
8733 PyThreadState* __tstate = wxPyBeginAllowThreads();
8734 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 resultobj = SWIG_From_double(static_cast< double >(result));
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj = 0;
8747 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8748 wxPoint2D *arg2 = 0 ;
8749 double result;
8750 void *argp1 = 0 ;
8751 int res1 = 0 ;
8752 wxPoint2D temp2 ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 char * kwnames[] = {
8756 (char *) "self",(char *) "vec", NULL
8757 };
8758
8759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8761 if (!SWIG_IsOK(res1)) {
8762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8763 }
8764 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8765 {
8766 arg2 = &temp2;
8767 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8768 }
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8772 wxPyEndAllowThreads(__tstate);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_From_double(static_cast< double >(result));
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D result;
8786 void *argp1 = 0 ;
8787 int res1 = 0 ;
8788 PyObject *swig_obj[1] ;
8789
8790 if (!args) SWIG_fail;
8791 swig_obj[0] = args;
8792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8793 if (!SWIG_IsOK(res1)) {
8794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8795 }
8796 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8797 {
8798 PyThreadState* __tstate = wxPyBeginAllowThreads();
8799 result = (arg1)->operator -();
8800 wxPyEndAllowThreads(__tstate);
8801 if (PyErr_Occurred()) SWIG_fail;
8802 }
8803 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8804 return resultobj;
8805 fail:
8806 return NULL;
8807 }
8808
8809
8810 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8811 PyObject *resultobj = 0;
8812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8813 wxPoint2D *arg2 = 0 ;
8814 wxPoint2D *result = 0 ;
8815 void *argp1 = 0 ;
8816 int res1 = 0 ;
8817 wxPoint2D temp2 ;
8818 PyObject * obj0 = 0 ;
8819 PyObject * obj1 = 0 ;
8820 char * kwnames[] = {
8821 (char *) "self",(char *) "pt", NULL
8822 };
8823
8824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8826 if (!SWIG_IsOK(res1)) {
8827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8828 }
8829 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8830 {
8831 arg2 = &temp2;
8832 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 {
8837 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8838 result = (wxPoint2D *) &_result_ref;
8839 }
8840 wxPyEndAllowThreads(__tstate);
8841 if (PyErr_Occurred()) SWIG_fail;
8842 }
8843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8851 PyObject *resultobj = 0;
8852 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8853 wxPoint2D *arg2 = 0 ;
8854 wxPoint2D *result = 0 ;
8855 void *argp1 = 0 ;
8856 int res1 = 0 ;
8857 wxPoint2D temp2 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 char * kwnames[] = {
8861 (char *) "self",(char *) "pt", NULL
8862 };
8863
8864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8868 }
8869 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8870 {
8871 arg2 = &temp2;
8872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8873 }
8874 {
8875 PyThreadState* __tstate = wxPyBeginAllowThreads();
8876 {
8877 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8878 result = (wxPoint2D *) &_result_ref;
8879 }
8880 wxPyEndAllowThreads(__tstate);
8881 if (PyErr_Occurred()) SWIG_fail;
8882 }
8883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8893 wxPoint2D *arg2 = 0 ;
8894 wxPoint2D *result = 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 wxPoint2D temp2 ;
8898 PyObject * obj0 = 0 ;
8899 PyObject * obj1 = 0 ;
8900 char * kwnames[] = {
8901 (char *) "self",(char *) "pt", NULL
8902 };
8903
8904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8906 if (!SWIG_IsOK(res1)) {
8907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8908 }
8909 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8910 {
8911 arg2 = &temp2;
8912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8913 }
8914 {
8915 PyThreadState* __tstate = wxPyBeginAllowThreads();
8916 {
8917 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8918 result = (wxPoint2D *) &_result_ref;
8919 }
8920 wxPyEndAllowThreads(__tstate);
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj = 0;
8932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8933 wxPoint2D *arg2 = 0 ;
8934 wxPoint2D *result = 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 wxPoint2D temp2 ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 char * kwnames[] = {
8941 (char *) "self",(char *) "pt", NULL
8942 };
8943
8944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8946 if (!SWIG_IsOK(res1)) {
8947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8948 }
8949 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8950 {
8951 arg2 = &temp2;
8952 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8953 }
8954 {
8955 PyThreadState* __tstate = wxPyBeginAllowThreads();
8956 {
8957 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8958 result = (wxPoint2D *) &_result_ref;
8959 }
8960 wxPyEndAllowThreads(__tstate);
8961 if (PyErr_Occurred()) SWIG_fail;
8962 }
8963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8964 return resultobj;
8965 fail:
8966 return NULL;
8967 }
8968
8969
8970 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8971 PyObject *resultobj = 0;
8972 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8973 PyObject *arg2 = (PyObject *) 0 ;
8974 bool result;
8975 void *argp1 = 0 ;
8976 int res1 = 0 ;
8977 PyObject * obj0 = 0 ;
8978 PyObject * obj1 = 0 ;
8979 char * kwnames[] = {
8980 (char *) "self",(char *) "other", NULL
8981 };
8982
8983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8985 if (!SWIG_IsOK(res1)) {
8986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8987 }
8988 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8989 arg2 = obj1;
8990 {
8991 result = (bool)wxPoint2D___eq__(arg1,arg2);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 {
8995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8996 }
8997 return resultobj;
8998 fail:
8999 return NULL;
9000 }
9001
9002
9003 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9004 PyObject *resultobj = 0;
9005 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9006 PyObject *arg2 = (PyObject *) 0 ;
9007 bool result;
9008 void *argp1 = 0 ;
9009 int res1 = 0 ;
9010 PyObject * obj0 = 0 ;
9011 PyObject * obj1 = 0 ;
9012 char * kwnames[] = {
9013 (char *) "self",(char *) "other", NULL
9014 };
9015
9016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 arg2 = obj1;
9023 {
9024 result = (bool)wxPoint2D___ne__(arg1,arg2);
9025 if (PyErr_Occurred()) SWIG_fail;
9026 }
9027 {
9028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9029 }
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9037 PyObject *resultobj = 0;
9038 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9039 double arg2 ;
9040 void *argp1 = 0 ;
9041 int res1 = 0 ;
9042 double val2 ;
9043 int ecode2 = 0 ;
9044 PyObject *swig_obj[2] ;
9045
9046 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9050 }
9051 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9052 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9053 if (!SWIG_IsOK(ecode2)) {
9054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9055 }
9056 arg2 = static_cast< double >(val2);
9057 if (arg1) (arg1)->m_x = arg2;
9058
9059 resultobj = SWIG_Py_Void();
9060 return resultobj;
9061 fail:
9062 return NULL;
9063 }
9064
9065
9066 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9067 PyObject *resultobj = 0;
9068 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9069 double result;
9070 void *argp1 = 0 ;
9071 int res1 = 0 ;
9072 PyObject *swig_obj[1] ;
9073
9074 if (!args) SWIG_fail;
9075 swig_obj[0] = args;
9076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9077 if (!SWIG_IsOK(res1)) {
9078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9079 }
9080 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9081 result = (double) ((arg1)->m_x);
9082 resultobj = SWIG_From_double(static_cast< double >(result));
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9090 PyObject *resultobj = 0;
9091 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9092 double arg2 ;
9093 void *argp1 = 0 ;
9094 int res1 = 0 ;
9095 double val2 ;
9096 int ecode2 = 0 ;
9097 PyObject *swig_obj[2] ;
9098
9099 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9103 }
9104 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9105 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9106 if (!SWIG_IsOK(ecode2)) {
9107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9108 }
9109 arg2 = static_cast< double >(val2);
9110 if (arg1) (arg1)->m_y = arg2;
9111
9112 resultobj = SWIG_Py_Void();
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9120 PyObject *resultobj = 0;
9121 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9122 double result;
9123 void *argp1 = 0 ;
9124 int res1 = 0 ;
9125 PyObject *swig_obj[1] ;
9126
9127 if (!args) SWIG_fail;
9128 swig_obj[0] = args;
9129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9130 if (!SWIG_IsOK(res1)) {
9131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9132 }
9133 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9134 result = (double) ((arg1)->m_y);
9135 resultobj = SWIG_From_double(static_cast< double >(result));
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj = 0;
9144 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9145 double arg2 = (double) 0 ;
9146 double arg3 = (double) 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 double val2 ;
9150 int ecode2 = 0 ;
9151 double val3 ;
9152 int ecode3 = 0 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 PyObject * obj2 = 0 ;
9156 char * kwnames[] = {
9157 (char *) "self",(char *) "x",(char *) "y", NULL
9158 };
9159
9160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9162 if (!SWIG_IsOK(res1)) {
9163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9164 }
9165 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9166 if (obj1) {
9167 ecode2 = SWIG_AsVal_double(obj1, &val2);
9168 if (!SWIG_IsOK(ecode2)) {
9169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9170 }
9171 arg2 = static_cast< double >(val2);
9172 }
9173 if (obj2) {
9174 ecode3 = SWIG_AsVal_double(obj2, &val3);
9175 if (!SWIG_IsOK(ecode3)) {
9176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9177 }
9178 arg3 = static_cast< double >(val3);
9179 }
9180 {
9181 PyThreadState* __tstate = wxPyBeginAllowThreads();
9182 wxPoint2D_Set(arg1,arg2,arg3);
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 resultobj = SWIG_Py_Void();
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9194 PyObject *resultobj = 0;
9195 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9196 PyObject *result = 0 ;
9197 void *argp1 = 0 ;
9198 int res1 = 0 ;
9199 PyObject *swig_obj[1] ;
9200
9201 if (!args) SWIG_fail;
9202 swig_obj[0] = args;
9203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9204 if (!SWIG_IsOK(res1)) {
9205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9206 }
9207 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 result = (PyObject *)wxPoint2D_Get(arg1);
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 resultobj = result;
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 PyObject *obj;
9223 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9224 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9225 return SWIG_Py_Void();
9226 }
9227
9228 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9229 return SWIG_Python_InitShadowInstance(args);
9230 }
9231
9232 SWIGINTERN int DefaultPosition_set(PyObject *) {
9233 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9234 return 1;
9235 }
9236
9237
9238 SWIGINTERN PyObject *DefaultPosition_get(void) {
9239 PyObject *pyobj = 0;
9240
9241 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9242 return pyobj;
9243 }
9244
9245
9246 SWIGINTERN int DefaultSize_set(PyObject *) {
9247 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9248 return 1;
9249 }
9250
9251
9252 SWIGINTERN PyObject *DefaultSize_get(void) {
9253 PyObject *pyobj = 0;
9254
9255 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9256 return pyobj;
9257 }
9258
9259
9260 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9261 PyObject *resultobj = 0;
9262 PyObject *arg1 = (PyObject *) 0 ;
9263 wxPyInputStream *result = 0 ;
9264 PyObject * obj0 = 0 ;
9265 char * kwnames[] = {
9266 (char *) "p", NULL
9267 };
9268
9269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9270 arg1 = obj0;
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9285 PyObject *resultobj = 0;
9286 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 PyObject *swig_obj[1] ;
9290
9291 if (!args) SWIG_fail;
9292 swig_obj[0] = args;
9293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9294 if (!SWIG_IsOK(res1)) {
9295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9296 }
9297 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 delete arg1;
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_Py_Void();
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9313 PyObject *resultobj = 0;
9314 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9315 void *argp1 = 0 ;
9316 int res1 = 0 ;
9317 PyObject *swig_obj[1] ;
9318
9319 if (!args) SWIG_fail;
9320 swig_obj[0] = args;
9321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9322 if (!SWIG_IsOK(res1)) {
9323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9324 }
9325 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 (arg1)->close();
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 resultobj = SWIG_Py_Void();
9333 return resultobj;
9334 fail:
9335 return NULL;
9336 }
9337
9338
9339 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9340 PyObject *resultobj = 0;
9341 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9342 void *argp1 = 0 ;
9343 int res1 = 0 ;
9344 PyObject *swig_obj[1] ;
9345
9346 if (!args) SWIG_fail;
9347 swig_obj[0] = args;
9348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9349 if (!SWIG_IsOK(res1)) {
9350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9351 }
9352 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 (arg1)->flush();
9356 wxPyEndAllowThreads(__tstate);
9357 if (PyErr_Occurred()) SWIG_fail;
9358 }
9359 resultobj = SWIG_Py_Void();
9360 return resultobj;
9361 fail:
9362 return NULL;
9363 }
9364
9365
9366 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9367 PyObject *resultobj = 0;
9368 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9369 bool result;
9370 void *argp1 = 0 ;
9371 int res1 = 0 ;
9372 PyObject *swig_obj[1] ;
9373
9374 if (!args) SWIG_fail;
9375 swig_obj[0] = args;
9376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9377 if (!SWIG_IsOK(res1)) {
9378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9379 }
9380 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (bool)(arg1)->eof();
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 {
9388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9389 }
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj = 0;
9398 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9399 int arg2 = (int) -1 ;
9400 PyObject *result = 0 ;
9401 void *argp1 = 0 ;
9402 int res1 = 0 ;
9403 int val2 ;
9404 int ecode2 = 0 ;
9405 PyObject * obj0 = 0 ;
9406 PyObject * obj1 = 0 ;
9407 char * kwnames[] = {
9408 (char *) "self",(char *) "size", NULL
9409 };
9410
9411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9413 if (!SWIG_IsOK(res1)) {
9414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9415 }
9416 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9417 if (obj1) {
9418 ecode2 = SWIG_AsVal_int(obj1, &val2);
9419 if (!SWIG_IsOK(ecode2)) {
9420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9421 }
9422 arg2 = static_cast< int >(val2);
9423 }
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (PyObject *)(arg1)->read(arg2);
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 resultobj = result;
9431 return resultobj;
9432 fail:
9433 return NULL;
9434 }
9435
9436
9437 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9438 PyObject *resultobj = 0;
9439 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9440 int arg2 = (int) -1 ;
9441 PyObject *result = 0 ;
9442 void *argp1 = 0 ;
9443 int res1 = 0 ;
9444 int val2 ;
9445 int ecode2 = 0 ;
9446 PyObject * obj0 = 0 ;
9447 PyObject * obj1 = 0 ;
9448 char * kwnames[] = {
9449 (char *) "self",(char *) "size", NULL
9450 };
9451
9452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 if (obj1) {
9459 ecode2 = SWIG_AsVal_int(obj1, &val2);
9460 if (!SWIG_IsOK(ecode2)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9462 }
9463 arg2 = static_cast< int >(val2);
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (PyObject *)(arg1)->readline(arg2);
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = result;
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9479 PyObject *resultobj = 0;
9480 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9481 int arg2 = (int) -1 ;
9482 PyObject *result = 0 ;
9483 void *argp1 = 0 ;
9484 int res1 = 0 ;
9485 int val2 ;
9486 int ecode2 = 0 ;
9487 PyObject * obj0 = 0 ;
9488 PyObject * obj1 = 0 ;
9489 char * kwnames[] = {
9490 (char *) "self",(char *) "sizehint", NULL
9491 };
9492
9493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9495 if (!SWIG_IsOK(res1)) {
9496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9497 }
9498 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9499 if (obj1) {
9500 ecode2 = SWIG_AsVal_int(obj1, &val2);
9501 if (!SWIG_IsOK(ecode2)) {
9502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9503 }
9504 arg2 = static_cast< int >(val2);
9505 }
9506 {
9507 PyThreadState* __tstate = wxPyBeginAllowThreads();
9508 result = (PyObject *)(arg1)->readlines(arg2);
9509 wxPyEndAllowThreads(__tstate);
9510 if (PyErr_Occurred()) SWIG_fail;
9511 }
9512 resultobj = result;
9513 return resultobj;
9514 fail:
9515 return NULL;
9516 }
9517
9518
9519 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9520 PyObject *resultobj = 0;
9521 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9522 int arg2 ;
9523 int arg3 = (int) 0 ;
9524 void *argp1 = 0 ;
9525 int res1 = 0 ;
9526 int val2 ;
9527 int ecode2 = 0 ;
9528 int val3 ;
9529 int ecode3 = 0 ;
9530 PyObject * obj0 = 0 ;
9531 PyObject * obj1 = 0 ;
9532 PyObject * obj2 = 0 ;
9533 char * kwnames[] = {
9534 (char *) "self",(char *) "offset",(char *) "whence", NULL
9535 };
9536
9537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9539 if (!SWIG_IsOK(res1)) {
9540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9541 }
9542 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9543 ecode2 = SWIG_AsVal_int(obj1, &val2);
9544 if (!SWIG_IsOK(ecode2)) {
9545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9546 }
9547 arg2 = static_cast< int >(val2);
9548 if (obj2) {
9549 ecode3 = SWIG_AsVal_int(obj2, &val3);
9550 if (!SWIG_IsOK(ecode3)) {
9551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9552 }
9553 arg3 = static_cast< int >(val3);
9554 }
9555 {
9556 PyThreadState* __tstate = wxPyBeginAllowThreads();
9557 (arg1)->seek(arg2,arg3);
9558 wxPyEndAllowThreads(__tstate);
9559 if (PyErr_Occurred()) SWIG_fail;
9560 }
9561 resultobj = SWIG_Py_Void();
9562 return resultobj;
9563 fail:
9564 return NULL;
9565 }
9566
9567
9568 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9569 PyObject *resultobj = 0;
9570 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9571 int result;
9572 void *argp1 = 0 ;
9573 int res1 = 0 ;
9574 PyObject *swig_obj[1] ;
9575
9576 if (!args) SWIG_fail;
9577 swig_obj[0] = args;
9578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9579 if (!SWIG_IsOK(res1)) {
9580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9581 }
9582 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (int)(arg1)->tell();
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_From_int(static_cast< int >(result));
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9597 PyObject *resultobj = 0;
9598 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9599 char result;
9600 void *argp1 = 0 ;
9601 int res1 = 0 ;
9602 PyObject *swig_obj[1] ;
9603
9604 if (!args) SWIG_fail;
9605 swig_obj[0] = args;
9606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9607 if (!SWIG_IsOK(res1)) {
9608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9609 }
9610 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 result = (char)(arg1)->Peek();
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 resultobj = SWIG_From_char(static_cast< char >(result));
9618 return resultobj;
9619 fail:
9620 return NULL;
9621 }
9622
9623
9624 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9625 PyObject *resultobj = 0;
9626 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9627 char result;
9628 void *argp1 = 0 ;
9629 int res1 = 0 ;
9630 PyObject *swig_obj[1] ;
9631
9632 if (!args) SWIG_fail;
9633 swig_obj[0] = args;
9634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9635 if (!SWIG_IsOK(res1)) {
9636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9637 }
9638 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9639 {
9640 PyThreadState* __tstate = wxPyBeginAllowThreads();
9641 result = (char)(arg1)->GetC();
9642 wxPyEndAllowThreads(__tstate);
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 resultobj = SWIG_From_char(static_cast< char >(result));
9646 return resultobj;
9647 fail:
9648 return NULL;
9649 }
9650
9651
9652 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9653 PyObject *resultobj = 0;
9654 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9655 size_t result;
9656 void *argp1 = 0 ;
9657 int res1 = 0 ;
9658 PyObject *swig_obj[1] ;
9659
9660 if (!args) SWIG_fail;
9661 swig_obj[0] = args;
9662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9663 if (!SWIG_IsOK(res1)) {
9664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9665 }
9666 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9667 {
9668 PyThreadState* __tstate = wxPyBeginAllowThreads();
9669 result = (size_t)(arg1)->LastRead();
9670 wxPyEndAllowThreads(__tstate);
9671 if (PyErr_Occurred()) SWIG_fail;
9672 }
9673 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9674 return resultobj;
9675 fail:
9676 return NULL;
9677 }
9678
9679
9680 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9681 PyObject *resultobj = 0;
9682 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9683 bool result;
9684 void *argp1 = 0 ;
9685 int res1 = 0 ;
9686 PyObject *swig_obj[1] ;
9687
9688 if (!args) SWIG_fail;
9689 swig_obj[0] = args;
9690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9691 if (!SWIG_IsOK(res1)) {
9692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9693 }
9694 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9695 {
9696 PyThreadState* __tstate = wxPyBeginAllowThreads();
9697 result = (bool)(arg1)->CanRead();
9698 wxPyEndAllowThreads(__tstate);
9699 if (PyErr_Occurred()) SWIG_fail;
9700 }
9701 {
9702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9703 }
9704 return resultobj;
9705 fail:
9706 return NULL;
9707 }
9708
9709
9710 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9711 PyObject *resultobj = 0;
9712 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9713 bool result;
9714 void *argp1 = 0 ;
9715 int res1 = 0 ;
9716 PyObject *swig_obj[1] ;
9717
9718 if (!args) SWIG_fail;
9719 swig_obj[0] = args;
9720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9721 if (!SWIG_IsOK(res1)) {
9722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9723 }
9724 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9725 {
9726 PyThreadState* __tstate = wxPyBeginAllowThreads();
9727 result = (bool)(arg1)->Eof();
9728 wxPyEndAllowThreads(__tstate);
9729 if (PyErr_Occurred()) SWIG_fail;
9730 }
9731 {
9732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9733 }
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj = 0;
9742 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9743 char arg2 ;
9744 bool result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 char val2 ;
9748 int ecode2 = 0 ;
9749 PyObject * obj0 = 0 ;
9750 PyObject * obj1 = 0 ;
9751 char * kwnames[] = {
9752 (char *) "self",(char *) "c", NULL
9753 };
9754
9755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9757 if (!SWIG_IsOK(res1)) {
9758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9759 }
9760 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9761 ecode2 = SWIG_AsVal_char(obj1, &val2);
9762 if (!SWIG_IsOK(ecode2)) {
9763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9764 }
9765 arg2 = static_cast< char >(val2);
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = (bool)(arg1)->Ungetch(arg2);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 {
9773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9774 }
9775 return resultobj;
9776 fail:
9777 return NULL;
9778 }
9779
9780
9781 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj = 0;
9783 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9784 long arg2 ;
9785 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9786 long result;
9787 void *argp1 = 0 ;
9788 int res1 = 0 ;
9789 long val2 ;
9790 int ecode2 = 0 ;
9791 int val3 ;
9792 int ecode3 = 0 ;
9793 PyObject * obj0 = 0 ;
9794 PyObject * obj1 = 0 ;
9795 PyObject * obj2 = 0 ;
9796 char * kwnames[] = {
9797 (char *) "self",(char *) "pos",(char *) "mode", NULL
9798 };
9799
9800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9802 if (!SWIG_IsOK(res1)) {
9803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9804 }
9805 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9806 ecode2 = SWIG_AsVal_long(obj1, &val2);
9807 if (!SWIG_IsOK(ecode2)) {
9808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9809 }
9810 arg2 = static_cast< long >(val2);
9811 if (obj2) {
9812 ecode3 = SWIG_AsVal_int(obj2, &val3);
9813 if (!SWIG_IsOK(ecode3)) {
9814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9815 }
9816 arg3 = static_cast< wxSeekMode >(val3);
9817 }
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 result = (long)(arg1)->SeekI(arg2,arg3);
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_From_long(static_cast< long >(result));
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9834 long result;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9844 }
9845 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (long)(arg1)->TellI();
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 resultobj = SWIG_From_long(static_cast< long >(result));
9853 return resultobj;
9854 fail:
9855 return NULL;
9856 }
9857
9858
9859 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9860 PyObject *obj;
9861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9862 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9863 return SWIG_Py_Void();
9864 }
9865
9866 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 return SWIG_Python_InitShadowInstance(args);
9868 }
9869
9870 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9871 PyObject *resultobj = 0;
9872 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9873 PyObject *arg2 = (PyObject *) 0 ;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 PyObject * obj0 = 0 ;
9877 PyObject * obj1 = 0 ;
9878 char * kwnames[] = {
9879 (char *) "self",(char *) "obj", NULL
9880 };
9881
9882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9884 if (!SWIG_IsOK(res1)) {
9885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9886 }
9887 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9888 arg2 = obj1;
9889 {
9890 PyThreadState* __tstate = wxPyBeginAllowThreads();
9891 wxOutputStream_write(arg1,arg2);
9892 wxPyEndAllowThreads(__tstate);
9893 if (PyErr_Occurred()) SWIG_fail;
9894 }
9895 resultobj = SWIG_Py_Void();
9896 return resultobj;
9897 fail:
9898 return NULL;
9899 }
9900
9901
9902 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9903 PyObject *resultobj = 0;
9904 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9905 size_t result;
9906 void *argp1 = 0 ;
9907 int res1 = 0 ;
9908 PyObject *swig_obj[1] ;
9909
9910 if (!args) SWIG_fail;
9911 swig_obj[0] = args;
9912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9913 if (!SWIG_IsOK(res1)) {
9914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9915 }
9916 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9917 {
9918 PyThreadState* __tstate = wxPyBeginAllowThreads();
9919 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9920 wxPyEndAllowThreads(__tstate);
9921 if (PyErr_Occurred()) SWIG_fail;
9922 }
9923 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *obj;
9932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9933 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9934 return SWIG_Py_Void();
9935 }
9936
9937 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9938 PyObject *resultobj = 0;
9939 wxInputStream *arg1 = (wxInputStream *) 0 ;
9940 wxString *arg2 = 0 ;
9941 wxString *arg3 = 0 ;
9942 wxString *arg4 = 0 ;
9943 wxDateTime arg5 ;
9944 wxFSFile *result = 0 ;
9945 wxPyInputStream *temp1 ;
9946 bool temp2 = false ;
9947 bool temp3 = false ;
9948 bool temp4 = false ;
9949 void *argp5 ;
9950 int res5 = 0 ;
9951 PyObject * obj0 = 0 ;
9952 PyObject * obj1 = 0 ;
9953 PyObject * obj2 = 0 ;
9954 PyObject * obj3 = 0 ;
9955 PyObject * obj4 = 0 ;
9956 char * kwnames[] = {
9957 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9958 };
9959
9960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9961 {
9962 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9963 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9964 } else {
9965 PyErr_Clear(); // clear the failure of the wxPyConvert above
9966 arg1 = wxPyCBInputStream_create(obj0, true);
9967 if (arg1 == NULL) {
9968 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9969 SWIG_fail;
9970 }
9971 }
9972 }
9973 {
9974 arg2 = wxString_in_helper(obj1);
9975 if (arg2 == NULL) SWIG_fail;
9976 temp2 = true;
9977 }
9978 {
9979 arg3 = wxString_in_helper(obj2);
9980 if (arg3 == NULL) SWIG_fail;
9981 temp3 = true;
9982 }
9983 {
9984 arg4 = wxString_in_helper(obj3);
9985 if (arg4 == NULL) SWIG_fail;
9986 temp4 = true;
9987 }
9988 {
9989 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9990 if (!SWIG_IsOK(res5)) {
9991 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9992 }
9993 if (!argp5) {
9994 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9995 } else {
9996 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9997 arg5 = *temp;
9998 if (SWIG_IsNewObj(res5)) delete temp;
9999 }
10000 }
10001 {
10002 PyThreadState* __tstate = wxPyBeginAllowThreads();
10003 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10004 wxPyEndAllowThreads(__tstate);
10005 if (PyErr_Occurred()) SWIG_fail;
10006 }
10007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10008 {
10009 if (temp2)
10010 delete arg2;
10011 }
10012 {
10013 if (temp3)
10014 delete arg3;
10015 }
10016 {
10017 if (temp4)
10018 delete arg4;
10019 }
10020 return resultobj;
10021 fail:
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 {
10027 if (temp3)
10028 delete arg3;
10029 }
10030 {
10031 if (temp4)
10032 delete arg4;
10033 }
10034 return NULL;
10035 }
10036
10037
10038 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10039 PyObject *resultobj = 0;
10040 wxFSFile *arg1 = (wxFSFile *) 0 ;
10041 void *argp1 = 0 ;
10042 int res1 = 0 ;
10043 PyObject *swig_obj[1] ;
10044
10045 if (!args) SWIG_fail;
10046 swig_obj[0] = args;
10047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10048 if (!SWIG_IsOK(res1)) {
10049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10050 }
10051 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10052 {
10053 PyThreadState* __tstate = wxPyBeginAllowThreads();
10054 delete arg1;
10055
10056 wxPyEndAllowThreads(__tstate);
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 resultobj = SWIG_Py_Void();
10060 return resultobj;
10061 fail:
10062 return NULL;
10063 }
10064
10065
10066 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10067 PyObject *resultobj = 0;
10068 wxFSFile *arg1 = (wxFSFile *) 0 ;
10069 wxInputStream *result = 0 ;
10070 void *argp1 = 0 ;
10071 int res1 = 0 ;
10072 PyObject *swig_obj[1] ;
10073
10074 if (!args) SWIG_fail;
10075 swig_obj[0] = args;
10076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10077 if (!SWIG_IsOK(res1)) {
10078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10079 }
10080 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10081 {
10082 PyThreadState* __tstate = wxPyBeginAllowThreads();
10083 result = (wxInputStream *)(arg1)->GetStream();
10084 wxPyEndAllowThreads(__tstate);
10085 if (PyErr_Occurred()) SWIG_fail;
10086 }
10087 {
10088 wxPyInputStream * _ptr = NULL;
10089
10090 if (result) {
10091 _ptr = new wxPyInputStream(result);
10092 }
10093 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10094 }
10095 return resultobj;
10096 fail:
10097 return NULL;
10098 }
10099
10100
10101 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10102 PyObject *resultobj = 0;
10103 wxFSFile *arg1 = (wxFSFile *) 0 ;
10104 void *argp1 = 0 ;
10105 int res1 = 0 ;
10106 PyObject *swig_obj[1] ;
10107
10108 if (!args) SWIG_fail;
10109 swig_obj[0] = args;
10110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10111 if (!SWIG_IsOK(res1)) {
10112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10113 }
10114 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->DetachStream();
10118 wxPyEndAllowThreads(__tstate);
10119 if (PyErr_Occurred()) SWIG_fail;
10120 }
10121 resultobj = SWIG_Py_Void();
10122 return resultobj;
10123 fail:
10124 return NULL;
10125 }
10126
10127
10128 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10129 PyObject *resultobj = 0;
10130 wxFSFile *arg1 = (wxFSFile *) 0 ;
10131 wxString *result = 0 ;
10132 void *argp1 = 0 ;
10133 int res1 = 0 ;
10134 PyObject *swig_obj[1] ;
10135
10136 if (!args) SWIG_fail;
10137 swig_obj[0] = args;
10138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10141 }
10142 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10143 {
10144 PyThreadState* __tstate = wxPyBeginAllowThreads();
10145 {
10146 wxString const &_result_ref = (arg1)->GetMimeType();
10147 result = (wxString *) &_result_ref;
10148 }
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 {
10153 #if wxUSE_UNICODE
10154 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10155 #else
10156 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10157 #endif
10158 }
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 PyObject *resultobj = 0;
10167 wxFSFile *arg1 = (wxFSFile *) 0 ;
10168 wxString *result = 0 ;
10169 void *argp1 = 0 ;
10170 int res1 = 0 ;
10171 PyObject *swig_obj[1] ;
10172
10173 if (!args) SWIG_fail;
10174 swig_obj[0] = args;
10175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10176 if (!SWIG_IsOK(res1)) {
10177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10178 }
10179 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10180 {
10181 PyThreadState* __tstate = wxPyBeginAllowThreads();
10182 {
10183 wxString const &_result_ref = (arg1)->GetLocation();
10184 result = (wxString *) &_result_ref;
10185 }
10186 wxPyEndAllowThreads(__tstate);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 {
10190 #if wxUSE_UNICODE
10191 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10192 #else
10193 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10194 #endif
10195 }
10196 return resultobj;
10197 fail:
10198 return NULL;
10199 }
10200
10201
10202 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10203 PyObject *resultobj = 0;
10204 wxFSFile *arg1 = (wxFSFile *) 0 ;
10205 wxString *result = 0 ;
10206 void *argp1 = 0 ;
10207 int res1 = 0 ;
10208 PyObject *swig_obj[1] ;
10209
10210 if (!args) SWIG_fail;
10211 swig_obj[0] = args;
10212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10213 if (!SWIG_IsOK(res1)) {
10214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10215 }
10216 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 {
10220 wxString const &_result_ref = (arg1)->GetAnchor();
10221 result = (wxString *) &_result_ref;
10222 }
10223 wxPyEndAllowThreads(__tstate);
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 {
10227 #if wxUSE_UNICODE
10228 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10229 #else
10230 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10231 #endif
10232 }
10233 return resultobj;
10234 fail:
10235 return NULL;
10236 }
10237
10238
10239 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10240 PyObject *resultobj = 0;
10241 wxFSFile *arg1 = (wxFSFile *) 0 ;
10242 wxDateTime result;
10243 void *argp1 = 0 ;
10244 int res1 = 0 ;
10245 PyObject *swig_obj[1] ;
10246
10247 if (!args) SWIG_fail;
10248 swig_obj[0] = args;
10249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10250 if (!SWIG_IsOK(res1)) {
10251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10252 }
10253 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 result = (arg1)->GetModificationTime();
10257 wxPyEndAllowThreads(__tstate);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10261 return resultobj;
10262 fail:
10263 return NULL;
10264 }
10265
10266
10267 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10268 PyObject *obj;
10269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10270 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10271 return SWIG_Py_Void();
10272 }
10273
10274 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10275 return SWIG_Python_InitShadowInstance(args);
10276 }
10277
10278 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10279 PyObject *resultobj = 0;
10280 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10281 void *argp1 = 0 ;
10282 int res1 = 0 ;
10283 PyObject *swig_obj[1] ;
10284
10285 if (!args) SWIG_fail;
10286 swig_obj[0] = args;
10287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10288 if (!SWIG_IsOK(res1)) {
10289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10290 }
10291 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10292 {
10293 PyThreadState* __tstate = wxPyBeginAllowThreads();
10294 delete arg1;
10295
10296 wxPyEndAllowThreads(__tstate);
10297 if (PyErr_Occurred()) SWIG_fail;
10298 }
10299 resultobj = SWIG_Py_Void();
10300 return resultobj;
10301 fail:
10302 return NULL;
10303 }
10304
10305
10306 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10307 PyObject *obj;
10308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10309 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10310 return SWIG_Py_Void();
10311 }
10312
10313 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10314 PyObject *resultobj = 0;
10315 wxPyFileSystemHandler *result = 0 ;
10316
10317 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10318 {
10319 PyThreadState* __tstate = wxPyBeginAllowThreads();
10320 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10325 return resultobj;
10326 fail:
10327 return NULL;
10328 }
10329
10330
10331 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10332 PyObject *resultobj = 0;
10333 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10334 PyObject *arg2 = (PyObject *) 0 ;
10335 PyObject *arg3 = (PyObject *) 0 ;
10336 void *argp1 = 0 ;
10337 int res1 = 0 ;
10338 PyObject * obj0 = 0 ;
10339 PyObject * obj1 = 0 ;
10340 PyObject * obj2 = 0 ;
10341 char * kwnames[] = {
10342 (char *) "self",(char *) "self",(char *) "_class", NULL
10343 };
10344
10345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10347 if (!SWIG_IsOK(res1)) {
10348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10349 }
10350 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10351 arg2 = obj1;
10352 arg3 = obj2;
10353 {
10354 PyThreadState* __tstate = wxPyBeginAllowThreads();
10355 (arg1)->_setCallbackInfo(arg2,arg3);
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 resultobj = SWIG_Py_Void();
10360 return resultobj;
10361 fail:
10362 return NULL;
10363 }
10364
10365
10366 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10367 PyObject *resultobj = 0;
10368 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10369 wxString *arg2 = 0 ;
10370 bool result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 bool temp2 = false ;
10374 PyObject * obj0 = 0 ;
10375 PyObject * obj1 = 0 ;
10376 char * kwnames[] = {
10377 (char *) "self",(char *) "location", NULL
10378 };
10379
10380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10384 }
10385 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10386 {
10387 arg2 = wxString_in_helper(obj1);
10388 if (arg2 == NULL) SWIG_fail;
10389 temp2 = true;
10390 }
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10394 wxPyEndAllowThreads(__tstate);
10395 if (PyErr_Occurred()) SWIG_fail;
10396 }
10397 {
10398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10399 }
10400 {
10401 if (temp2)
10402 delete arg2;
10403 }
10404 return resultobj;
10405 fail:
10406 {
10407 if (temp2)
10408 delete arg2;
10409 }
10410 return NULL;
10411 }
10412
10413
10414 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj = 0;
10416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10417 wxFileSystem *arg2 = 0 ;
10418 wxString *arg3 = 0 ;
10419 wxFSFile *result = 0 ;
10420 void *argp1 = 0 ;
10421 int res1 = 0 ;
10422 void *argp2 = 0 ;
10423 int res2 = 0 ;
10424 bool temp3 = false ;
10425 PyObject * obj0 = 0 ;
10426 PyObject * obj1 = 0 ;
10427 PyObject * obj2 = 0 ;
10428 char * kwnames[] = {
10429 (char *) "self",(char *) "fs",(char *) "location", NULL
10430 };
10431
10432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10434 if (!SWIG_IsOK(res1)) {
10435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10436 }
10437 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10439 if (!SWIG_IsOK(res2)) {
10440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10441 }
10442 if (!argp2) {
10443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10444 }
10445 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10446 {
10447 arg3 = wxString_in_helper(obj2);
10448 if (arg3 == NULL) SWIG_fail;
10449 temp3 = true;
10450 }
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10454 wxPyEndAllowThreads(__tstate);
10455 if (PyErr_Occurred()) SWIG_fail;
10456 }
10457 {
10458 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10459 }
10460 {
10461 if (temp3)
10462 delete arg3;
10463 }
10464 return resultobj;
10465 fail:
10466 {
10467 if (temp3)
10468 delete arg3;
10469 }
10470 return NULL;
10471 }
10472
10473
10474 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj = 0;
10476 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10477 wxString *arg2 = 0 ;
10478 int arg3 = (int) 0 ;
10479 wxString result;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 bool temp2 = false ;
10483 int val3 ;
10484 int ecode3 = 0 ;
10485 PyObject * obj0 = 0 ;
10486 PyObject * obj1 = 0 ;
10487 PyObject * obj2 = 0 ;
10488 char * kwnames[] = {
10489 (char *) "self",(char *) "spec",(char *) "flags", NULL
10490 };
10491
10492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10496 }
10497 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10498 {
10499 arg2 = wxString_in_helper(obj1);
10500 if (arg2 == NULL) SWIG_fail;
10501 temp2 = true;
10502 }
10503 if (obj2) {
10504 ecode3 = SWIG_AsVal_int(obj2, &val3);
10505 if (!SWIG_IsOK(ecode3)) {
10506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10507 }
10508 arg3 = static_cast< int >(val3);
10509 }
10510 {
10511 PyThreadState* __tstate = wxPyBeginAllowThreads();
10512 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10513 wxPyEndAllowThreads(__tstate);
10514 if (PyErr_Occurred()) SWIG_fail;
10515 }
10516 {
10517 #if wxUSE_UNICODE
10518 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10519 #else
10520 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10521 #endif
10522 }
10523 {
10524 if (temp2)
10525 delete arg2;
10526 }
10527 return resultobj;
10528 fail:
10529 {
10530 if (temp2)
10531 delete arg2;
10532 }
10533 return NULL;
10534 }
10535
10536
10537 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10538 PyObject *resultobj = 0;
10539 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10540 wxString result;
10541 void *argp1 = 0 ;
10542 int res1 = 0 ;
10543 PyObject *swig_obj[1] ;
10544
10545 if (!args) SWIG_fail;
10546 swig_obj[0] = args;
10547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10548 if (!SWIG_IsOK(res1)) {
10549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10550 }
10551 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (arg1)->FindNext();
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 {
10559 #if wxUSE_UNICODE
10560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10561 #else
10562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10563 #endif
10564 }
10565 return resultobj;
10566 fail:
10567 return NULL;
10568 }
10569
10570
10571 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10572 PyObject *resultobj = 0;
10573 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10574 wxString *arg2 = 0 ;
10575 wxString result;
10576 void *argp1 = 0 ;
10577 int res1 = 0 ;
10578 bool temp2 = false ;
10579 PyObject * obj0 = 0 ;
10580 PyObject * obj1 = 0 ;
10581 char * kwnames[] = {
10582 (char *) "self",(char *) "location", NULL
10583 };
10584
10585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10589 }
10590 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10591 {
10592 arg2 = wxString_in_helper(obj1);
10593 if (arg2 == NULL) SWIG_fail;
10594 temp2 = true;
10595 }
10596 {
10597 PyThreadState* __tstate = wxPyBeginAllowThreads();
10598 result = (arg1)->GetProtocol((wxString const &)*arg2);
10599 wxPyEndAllowThreads(__tstate);
10600 if (PyErr_Occurred()) SWIG_fail;
10601 }
10602 {
10603 #if wxUSE_UNICODE
10604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10605 #else
10606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10607 #endif
10608 }
10609 {
10610 if (temp2)
10611 delete arg2;
10612 }
10613 return resultobj;
10614 fail:
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return NULL;
10620 }
10621
10622
10623 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10624 PyObject *resultobj = 0;
10625 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10626 wxString *arg2 = 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 bool temp2 = false ;
10631 PyObject * obj0 = 0 ;
10632 PyObject * obj1 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "location", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10641 }
10642 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10643 {
10644 arg2 = wxString_in_helper(obj1);
10645 if (arg2 == NULL) SWIG_fail;
10646 temp2 = true;
10647 }
10648 {
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 {
10655 #if wxUSE_UNICODE
10656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10657 #else
10658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10659 #endif
10660 }
10661 {
10662 if (temp2)
10663 delete arg2;
10664 }
10665 return resultobj;
10666 fail:
10667 {
10668 if (temp2)
10669 delete arg2;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj = 0;
10677 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10678 wxString *arg2 = 0 ;
10679 wxString result;
10680 void *argp1 = 0 ;
10681 int res1 = 0 ;
10682 bool temp2 = false ;
10683 PyObject * obj0 = 0 ;
10684 PyObject * obj1 = 0 ;
10685 char * kwnames[] = {
10686 (char *) "self",(char *) "location", NULL
10687 };
10688
10689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10691 if (!SWIG_IsOK(res1)) {
10692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10693 }
10694 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10695 {
10696 arg2 = wxString_in_helper(obj1);
10697 if (arg2 == NULL) SWIG_fail;
10698 temp2 = true;
10699 }
10700 {
10701 PyThreadState* __tstate = wxPyBeginAllowThreads();
10702 result = (arg1)->GetAnchor((wxString const &)*arg2);
10703 wxPyEndAllowThreads(__tstate);
10704 if (PyErr_Occurred()) SWIG_fail;
10705 }
10706 {
10707 #if wxUSE_UNICODE
10708 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10709 #else
10710 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10711 #endif
10712 }
10713 {
10714 if (temp2)
10715 delete arg2;
10716 }
10717 return resultobj;
10718 fail:
10719 {
10720 if (temp2)
10721 delete arg2;
10722 }
10723 return NULL;
10724 }
10725
10726
10727 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj = 0;
10729 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10730 wxString *arg2 = 0 ;
10731 wxString result;
10732 void *argp1 = 0 ;
10733 int res1 = 0 ;
10734 bool temp2 = false ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 char * kwnames[] = {
10738 (char *) "self",(char *) "location", NULL
10739 };
10740
10741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10743 if (!SWIG_IsOK(res1)) {
10744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10745 }
10746 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10747 {
10748 arg2 = wxString_in_helper(obj1);
10749 if (arg2 == NULL) SWIG_fail;
10750 temp2 = true;
10751 }
10752 {
10753 PyThreadState* __tstate = wxPyBeginAllowThreads();
10754 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10755 wxPyEndAllowThreads(__tstate);
10756 if (PyErr_Occurred()) SWIG_fail;
10757 }
10758 {
10759 #if wxUSE_UNICODE
10760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10761 #else
10762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10763 #endif
10764 }
10765 {
10766 if (temp2)
10767 delete arg2;
10768 }
10769 return resultobj;
10770 fail:
10771 {
10772 if (temp2)
10773 delete arg2;
10774 }
10775 return NULL;
10776 }
10777
10778
10779 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj = 0;
10781 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10782 wxString *arg2 = 0 ;
10783 wxString result;
10784 void *argp1 = 0 ;
10785 int res1 = 0 ;
10786 bool temp2 = false ;
10787 PyObject * obj0 = 0 ;
10788 PyObject * obj1 = 0 ;
10789 char * kwnames[] = {
10790 (char *) "self",(char *) "location", NULL
10791 };
10792
10793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10795 if (!SWIG_IsOK(res1)) {
10796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10797 }
10798 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10799 {
10800 arg2 = wxString_in_helper(obj1);
10801 if (arg2 == NULL) SWIG_fail;
10802 temp2 = true;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10807 wxPyEndAllowThreads(__tstate);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 {
10811 #if wxUSE_UNICODE
10812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10813 #else
10814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10815 #endif
10816 }
10817 {
10818 if (temp2)
10819 delete arg2;
10820 }
10821 return resultobj;
10822 fail:
10823 {
10824 if (temp2)
10825 delete arg2;
10826 }
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10832 PyObject *obj;
10833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10834 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10835 return SWIG_Py_Void();
10836 }
10837
10838 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10839 return SWIG_Python_InitShadowInstance(args);
10840 }
10841
10842 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10843 PyObject *resultobj = 0;
10844 wxFileSystem *result = 0 ;
10845
10846 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = (wxFileSystem *)new wxFileSystem();
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 {
10854 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10855 }
10856 return resultobj;
10857 fail:
10858 return NULL;
10859 }
10860
10861
10862 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10863 PyObject *resultobj = 0;
10864 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10865 void *argp1 = 0 ;
10866 int res1 = 0 ;
10867 PyObject *swig_obj[1] ;
10868
10869 if (!args) SWIG_fail;
10870 swig_obj[0] = args;
10871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10874 }
10875 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10876 {
10877 PyThreadState* __tstate = wxPyBeginAllowThreads();
10878 delete arg1;
10879
10880 wxPyEndAllowThreads(__tstate);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10893 wxString *arg2 = 0 ;
10894 bool arg3 = (bool) false ;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 bool temp2 = false ;
10898 bool val3 ;
10899 int ecode3 = 0 ;
10900 PyObject * obj0 = 0 ;
10901 PyObject * obj1 = 0 ;
10902 PyObject * obj2 = 0 ;
10903 char * kwnames[] = {
10904 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10905 };
10906
10907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10909 if (!SWIG_IsOK(res1)) {
10910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10911 }
10912 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10913 {
10914 arg2 = wxString_in_helper(obj1);
10915 if (arg2 == NULL) SWIG_fail;
10916 temp2 = true;
10917 }
10918 if (obj2) {
10919 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10920 if (!SWIG_IsOK(ecode3)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10922 }
10923 arg3 = static_cast< bool >(val3);
10924 }
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10928 wxPyEndAllowThreads(__tstate);
10929 if (PyErr_Occurred()) SWIG_fail;
10930 }
10931 resultobj = SWIG_Py_Void();
10932 {
10933 if (temp2)
10934 delete arg2;
10935 }
10936 return resultobj;
10937 fail:
10938 {
10939 if (temp2)
10940 delete arg2;
10941 }
10942 return NULL;
10943 }
10944
10945
10946 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10947 PyObject *resultobj = 0;
10948 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10949 wxString result;
10950 void *argp1 = 0 ;
10951 int res1 = 0 ;
10952 PyObject *swig_obj[1] ;
10953
10954 if (!args) SWIG_fail;
10955 swig_obj[0] = args;
10956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10957 if (!SWIG_IsOK(res1)) {
10958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10959 }
10960 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10961 {
10962 PyThreadState* __tstate = wxPyBeginAllowThreads();
10963 result = (arg1)->GetPath();
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 {
10968 #if wxUSE_UNICODE
10969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10970 #else
10971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10972 #endif
10973 }
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj = 0;
10982 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10983 wxString *arg2 = 0 ;
10984 wxFSFile *result = 0 ;
10985 void *argp1 = 0 ;
10986 int res1 = 0 ;
10987 bool temp2 = false ;
10988 PyObject * obj0 = 0 ;
10989 PyObject * obj1 = 0 ;
10990 char * kwnames[] = {
10991 (char *) "self",(char *) "location", NULL
10992 };
10993
10994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10996 if (!SWIG_IsOK(res1)) {
10997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10998 }
10999 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11000 {
11001 arg2 = wxString_in_helper(obj1);
11002 if (arg2 == NULL) SWIG_fail;
11003 temp2 = true;
11004 }
11005 {
11006 PyThreadState* __tstate = wxPyBeginAllowThreads();
11007 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11013 }
11014 {
11015 if (temp2)
11016 delete arg2;
11017 }
11018 return resultobj;
11019 fail:
11020 {
11021 if (temp2)
11022 delete arg2;
11023 }
11024 return NULL;
11025 }
11026
11027
11028 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11029 PyObject *resultobj = 0;
11030 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11031 wxString *arg2 = 0 ;
11032 int arg3 = (int) 0 ;
11033 wxString result;
11034 void *argp1 = 0 ;
11035 int res1 = 0 ;
11036 bool temp2 = false ;
11037 int val3 ;
11038 int ecode3 = 0 ;
11039 PyObject * obj0 = 0 ;
11040 PyObject * obj1 = 0 ;
11041 PyObject * obj2 = 0 ;
11042 char * kwnames[] = {
11043 (char *) "self",(char *) "spec",(char *) "flags", NULL
11044 };
11045
11046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11048 if (!SWIG_IsOK(res1)) {
11049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11050 }
11051 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11052 {
11053 arg2 = wxString_in_helper(obj1);
11054 if (arg2 == NULL) SWIG_fail;
11055 temp2 = true;
11056 }
11057 if (obj2) {
11058 ecode3 = SWIG_AsVal_int(obj2, &val3);
11059 if (!SWIG_IsOK(ecode3)) {
11060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11061 }
11062 arg3 = static_cast< int >(val3);
11063 }
11064 {
11065 PyThreadState* __tstate = wxPyBeginAllowThreads();
11066 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11067 wxPyEndAllowThreads(__tstate);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 {
11071 #if wxUSE_UNICODE
11072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11073 #else
11074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11075 #endif
11076 }
11077 {
11078 if (temp2)
11079 delete arg2;
11080 }
11081 return resultobj;
11082 fail:
11083 {
11084 if (temp2)
11085 delete arg2;
11086 }
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11092 PyObject *resultobj = 0;
11093 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11094 wxString result;
11095 void *argp1 = 0 ;
11096 int res1 = 0 ;
11097 PyObject *swig_obj[1] ;
11098
11099 if (!args) SWIG_fail;
11100 swig_obj[0] = args;
11101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11102 if (!SWIG_IsOK(res1)) {
11103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11104 }
11105 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = (arg1)->FindNext();
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 #if wxUSE_UNICODE
11114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11115 #else
11116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11117 #endif
11118 }
11119 return resultobj;
11120 fail:
11121 return NULL;
11122 }
11123
11124
11125 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11126 PyObject *resultobj = 0;
11127 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11128 int res1 = 0 ;
11129 PyObject * obj0 = 0 ;
11130 char * kwnames[] = {
11131 (char *) "handler", NULL
11132 };
11133
11134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11135 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11136 if (!SWIG_IsOK(res1)) {
11137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11138 }
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 wxFileSystem::AddHandler(arg1);
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 resultobj = SWIG_Py_Void();
11146 return resultobj;
11147 fail:
11148 return NULL;
11149 }
11150
11151
11152 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11153 PyObject *resultobj = 0;
11154 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11155 wxFileSystemHandler *result = 0 ;
11156 void *argp1 = 0 ;
11157 int res1 = 0 ;
11158 PyObject * obj0 = 0 ;
11159 char * kwnames[] = {
11160 (char *) "handler", NULL
11161 };
11162
11163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11165 if (!SWIG_IsOK(res1)) {
11166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11167 }
11168 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11169 {
11170 PyThreadState* __tstate = wxPyBeginAllowThreads();
11171 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11172 wxPyEndAllowThreads(__tstate);
11173 if (PyErr_Occurred()) SWIG_fail;
11174 }
11175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11183 PyObject *resultobj = 0;
11184
11185 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 wxFileSystem::CleanUpHandlers();
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 resultobj = SWIG_Py_Void();
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11200 PyObject *resultobj = 0;
11201 wxString *arg1 = 0 ;
11202 wxString result;
11203 bool temp1 = false ;
11204 PyObject * obj0 = 0 ;
11205 char * kwnames[] = {
11206 (char *) "filename", NULL
11207 };
11208
11209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11210 {
11211 arg1 = wxString_in_helper(obj0);
11212 if (arg1 == NULL) SWIG_fail;
11213 temp1 = true;
11214 }
11215 {
11216 PyThreadState* __tstate = wxPyBeginAllowThreads();
11217 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11218 wxPyEndAllowThreads(__tstate);
11219 if (PyErr_Occurred()) SWIG_fail;
11220 }
11221 {
11222 #if wxUSE_UNICODE
11223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11224 #else
11225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11226 #endif
11227 }
11228 {
11229 if (temp1)
11230 delete arg1;
11231 }
11232 return resultobj;
11233 fail:
11234 {
11235 if (temp1)
11236 delete arg1;
11237 }
11238 return NULL;
11239 }
11240
11241
11242 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11243 PyObject *resultobj = 0;
11244 wxString *arg1 = 0 ;
11245 wxString result;
11246 bool temp1 = false ;
11247 PyObject * obj0 = 0 ;
11248 char * kwnames[] = {
11249 (char *) "url", NULL
11250 };
11251
11252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11253 {
11254 arg1 = wxString_in_helper(obj0);
11255 if (arg1 == NULL) SWIG_fail;
11256 temp1 = true;
11257 }
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11261 wxPyEndAllowThreads(__tstate);
11262 if (PyErr_Occurred()) SWIG_fail;
11263 }
11264 {
11265 #if wxUSE_UNICODE
11266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11267 #else
11268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11269 #endif
11270 }
11271 {
11272 if (temp1)
11273 delete arg1;
11274 }
11275 return resultobj;
11276 fail:
11277 {
11278 if (temp1)
11279 delete arg1;
11280 }
11281 return NULL;
11282 }
11283
11284
11285 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11286 PyObject *obj;
11287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11288 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11289 return SWIG_Py_Void();
11290 }
11291
11292 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11293 return SWIG_Python_InitShadowInstance(args);
11294 }
11295
11296 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11297 PyObject *resultobj = 0;
11298 wxInternetFSHandler *result = 0 ;
11299
11300 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11308 return resultobj;
11309 fail:
11310 return NULL;
11311 }
11312
11313
11314 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11315 PyObject *resultobj = 0;
11316 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11317 wxString *arg2 = 0 ;
11318 bool result;
11319 void *argp1 = 0 ;
11320 int res1 = 0 ;
11321 bool temp2 = false ;
11322 PyObject * obj0 = 0 ;
11323 PyObject * obj1 = 0 ;
11324 char * kwnames[] = {
11325 (char *) "self",(char *) "location", NULL
11326 };
11327
11328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11330 if (!SWIG_IsOK(res1)) {
11331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11332 }
11333 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11334 {
11335 arg2 = wxString_in_helper(obj1);
11336 if (arg2 == NULL) SWIG_fail;
11337 temp2 = true;
11338 }
11339 {
11340 PyThreadState* __tstate = wxPyBeginAllowThreads();
11341 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11342 wxPyEndAllowThreads(__tstate);
11343 if (PyErr_Occurred()) SWIG_fail;
11344 }
11345 {
11346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11347 }
11348 {
11349 if (temp2)
11350 delete arg2;
11351 }
11352 return resultobj;
11353 fail:
11354 {
11355 if (temp2)
11356 delete arg2;
11357 }
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11363 PyObject *resultobj = 0;
11364 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11365 wxFileSystem *arg2 = 0 ;
11366 wxString *arg3 = 0 ;
11367 wxFSFile *result = 0 ;
11368 void *argp1 = 0 ;
11369 int res1 = 0 ;
11370 void *argp2 = 0 ;
11371 int res2 = 0 ;
11372 bool temp3 = false ;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 char * kwnames[] = {
11377 (char *) "self",(char *) "fs",(char *) "location", NULL
11378 };
11379
11380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11382 if (!SWIG_IsOK(res1)) {
11383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11384 }
11385 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11386 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11387 if (!SWIG_IsOK(res2)) {
11388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11389 }
11390 if (!argp2) {
11391 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11392 }
11393 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11394 {
11395 arg3 = wxString_in_helper(obj2);
11396 if (arg3 == NULL) SWIG_fail;
11397 temp3 = true;
11398 }
11399 {
11400 PyThreadState* __tstate = wxPyBeginAllowThreads();
11401 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11402 wxPyEndAllowThreads(__tstate);
11403 if (PyErr_Occurred()) SWIG_fail;
11404 }
11405 {
11406 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11407 }
11408 {
11409 if (temp3)
11410 delete arg3;
11411 }
11412 return resultobj;
11413 fail:
11414 {
11415 if (temp3)
11416 delete arg3;
11417 }
11418 return NULL;
11419 }
11420
11421
11422 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423 PyObject *obj;
11424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11425 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11426 return SWIG_Py_Void();
11427 }
11428
11429 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11430 return SWIG_Python_InitShadowInstance(args);
11431 }
11432
11433 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11434 PyObject *resultobj = 0;
11435 wxZipFSHandler *result = 0 ;
11436
11437 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (wxZipFSHandler *)new wxZipFSHandler();
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj = 0;
11453 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11454 wxString *arg2 = 0 ;
11455 bool result;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 bool temp2 = false ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 char * kwnames[] = {
11462 (char *) "self",(char *) "location", NULL
11463 };
11464
11465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11467 if (!SWIG_IsOK(res1)) {
11468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11469 }
11470 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11471 {
11472 arg2 = wxString_in_helper(obj1);
11473 if (arg2 == NULL) SWIG_fail;
11474 temp2 = true;
11475 }
11476 {
11477 PyThreadState* __tstate = wxPyBeginAllowThreads();
11478 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11479 wxPyEndAllowThreads(__tstate);
11480 if (PyErr_Occurred()) SWIG_fail;
11481 }
11482 {
11483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11484 }
11485 {
11486 if (temp2)
11487 delete arg2;
11488 }
11489 return resultobj;
11490 fail:
11491 {
11492 if (temp2)
11493 delete arg2;
11494 }
11495 return NULL;
11496 }
11497
11498
11499 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11500 PyObject *resultobj = 0;
11501 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11502 wxFileSystem *arg2 = 0 ;
11503 wxString *arg3 = 0 ;
11504 wxFSFile *result = 0 ;
11505 void *argp1 = 0 ;
11506 int res1 = 0 ;
11507 void *argp2 = 0 ;
11508 int res2 = 0 ;
11509 bool temp3 = false ;
11510 PyObject * obj0 = 0 ;
11511 PyObject * obj1 = 0 ;
11512 PyObject * obj2 = 0 ;
11513 char * kwnames[] = {
11514 (char *) "self",(char *) "fs",(char *) "location", NULL
11515 };
11516
11517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11521 }
11522 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11524 if (!SWIG_IsOK(res2)) {
11525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11526 }
11527 if (!argp2) {
11528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11529 }
11530 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11531 {
11532 arg3 = wxString_in_helper(obj2);
11533 if (arg3 == NULL) SWIG_fail;
11534 temp3 = true;
11535 }
11536 {
11537 PyThreadState* __tstate = wxPyBeginAllowThreads();
11538 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 {
11543 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11544 }
11545 {
11546 if (temp3)
11547 delete arg3;
11548 }
11549 return resultobj;
11550 fail:
11551 {
11552 if (temp3)
11553 delete arg3;
11554 }
11555 return NULL;
11556 }
11557
11558
11559 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11560 PyObject *resultobj = 0;
11561 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11562 wxString *arg2 = 0 ;
11563 int arg3 = (int) 0 ;
11564 wxString result;
11565 void *argp1 = 0 ;
11566 int res1 = 0 ;
11567 bool temp2 = false ;
11568 int val3 ;
11569 int ecode3 = 0 ;
11570 PyObject * obj0 = 0 ;
11571 PyObject * obj1 = 0 ;
11572 PyObject * obj2 = 0 ;
11573 char * kwnames[] = {
11574 (char *) "self",(char *) "spec",(char *) "flags", NULL
11575 };
11576
11577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11579 if (!SWIG_IsOK(res1)) {
11580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11581 }
11582 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11583 {
11584 arg2 = wxString_in_helper(obj1);
11585 if (arg2 == NULL) SWIG_fail;
11586 temp2 = true;
11587 }
11588 if (obj2) {
11589 ecode3 = SWIG_AsVal_int(obj2, &val3);
11590 if (!SWIG_IsOK(ecode3)) {
11591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11592 }
11593 arg3 = static_cast< int >(val3);
11594 }
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11598 wxPyEndAllowThreads(__tstate);
11599 if (PyErr_Occurred()) SWIG_fail;
11600 }
11601 {
11602 #if wxUSE_UNICODE
11603 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11604 #else
11605 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11606 #endif
11607 }
11608 {
11609 if (temp2)
11610 delete arg2;
11611 }
11612 return resultobj;
11613 fail:
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11623 PyObject *resultobj = 0;
11624 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11625 wxString result;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 PyObject *swig_obj[1] ;
11629
11630 if (!args) SWIG_fail;
11631 swig_obj[0] = args;
11632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11633 if (!SWIG_IsOK(res1)) {
11634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11635 }
11636 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11637 {
11638 PyThreadState* __tstate = wxPyBeginAllowThreads();
11639 result = (arg1)->FindNext();
11640 wxPyEndAllowThreads(__tstate);
11641 if (PyErr_Occurred()) SWIG_fail;
11642 }
11643 {
11644 #if wxUSE_UNICODE
11645 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11646 #else
11647 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11648 #endif
11649 }
11650 return resultobj;
11651 fail:
11652 return NULL;
11653 }
11654
11655
11656 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11657 PyObject *obj;
11658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11659 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11660 return SWIG_Py_Void();
11661 }
11662
11663 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 return SWIG_Python_InitShadowInstance(args);
11665 }
11666
11667 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11668 PyObject *resultobj = 0;
11669 wxString *arg1 = 0 ;
11670 wxImage *arg2 = 0 ;
11671 long arg3 ;
11672 bool temp1 = false ;
11673 void *argp2 = 0 ;
11674 int res2 = 0 ;
11675 long val3 ;
11676 int ecode3 = 0 ;
11677 PyObject * obj0 = 0 ;
11678 PyObject * obj1 = 0 ;
11679 PyObject * obj2 = 0 ;
11680 char * kwnames[] = {
11681 (char *) "filename",(char *) "image",(char *) "type", NULL
11682 };
11683
11684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11685 {
11686 arg1 = wxString_in_helper(obj0);
11687 if (arg1 == NULL) SWIG_fail;
11688 temp1 = true;
11689 }
11690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11691 if (!SWIG_IsOK(res2)) {
11692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11693 }
11694 if (!argp2) {
11695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11696 }
11697 arg2 = reinterpret_cast< wxImage * >(argp2);
11698 ecode3 = SWIG_AsVal_long(obj2, &val3);
11699 if (!SWIG_IsOK(ecode3)) {
11700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11701 }
11702 arg3 = static_cast< long >(val3);
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11706 wxPyEndAllowThreads(__tstate);
11707 if (PyErr_Occurred()) SWIG_fail;
11708 }
11709 resultobj = SWIG_Py_Void();
11710 {
11711 if (temp1)
11712 delete arg1;
11713 }
11714 return resultobj;
11715 fail:
11716 {
11717 if (temp1)
11718 delete arg1;
11719 }
11720 return NULL;
11721 }
11722
11723
11724 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11725 PyObject *resultobj = 0;
11726 wxString *arg1 = 0 ;
11727 wxBitmap *arg2 = 0 ;
11728 long arg3 ;
11729 bool temp1 = false ;
11730 void *argp2 = 0 ;
11731 int res2 = 0 ;
11732 long val3 ;
11733 int ecode3 = 0 ;
11734 PyObject * obj0 = 0 ;
11735 PyObject * obj1 = 0 ;
11736 PyObject * obj2 = 0 ;
11737 char * kwnames[] = {
11738 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11739 };
11740
11741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11742 {
11743 arg1 = wxString_in_helper(obj0);
11744 if (arg1 == NULL) SWIG_fail;
11745 temp1 = true;
11746 }
11747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11748 if (!SWIG_IsOK(res2)) {
11749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11750 }
11751 if (!argp2) {
11752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11753 }
11754 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11755 ecode3 = SWIG_AsVal_long(obj2, &val3);
11756 if (!SWIG_IsOK(ecode3)) {
11757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11758 }
11759 arg3 = static_cast< long >(val3);
11760 {
11761 PyThreadState* __tstate = wxPyBeginAllowThreads();
11762 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11763 wxPyEndAllowThreads(__tstate);
11764 if (PyErr_Occurred()) SWIG_fail;
11765 }
11766 resultobj = SWIG_Py_Void();
11767 {
11768 if (temp1)
11769 delete arg1;
11770 }
11771 return resultobj;
11772 fail:
11773 {
11774 if (temp1)
11775 delete arg1;
11776 }
11777 return NULL;
11778 }
11779
11780
11781 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj = 0;
11783 wxString *arg1 = 0 ;
11784 PyObject *arg2 = (PyObject *) 0 ;
11785 bool temp1 = false ;
11786 PyObject * obj0 = 0 ;
11787 PyObject * obj1 = 0 ;
11788 char * kwnames[] = {
11789 (char *) "filename",(char *) "data", NULL
11790 };
11791
11792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11793 {
11794 arg1 = wxString_in_helper(obj0);
11795 if (arg1 == NULL) SWIG_fail;
11796 temp1 = true;
11797 }
11798 arg2 = obj1;
11799 {
11800 PyThreadState* __tstate = wxPyBeginAllowThreads();
11801 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11802 wxPyEndAllowThreads(__tstate);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 resultobj = SWIG_Py_Void();
11806 {
11807 if (temp1)
11808 delete arg1;
11809 }
11810 return resultobj;
11811 fail:
11812 {
11813 if (temp1)
11814 delete arg1;
11815 }
11816 return NULL;
11817 }
11818
11819
11820 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11821 PyObject *resultobj = 0;
11822 wxMemoryFSHandler *result = 0 ;
11823
11824 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj = 0;
11840 wxString *arg1 = 0 ;
11841 bool temp1 = false ;
11842 PyObject * obj0 = 0 ;
11843 char * kwnames[] = {
11844 (char *) "filename", NULL
11845 };
11846
11847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11848 {
11849 arg1 = wxString_in_helper(obj0);
11850 if (arg1 == NULL) SWIG_fail;
11851 temp1 = true;
11852 }
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 resultobj = SWIG_Py_Void();
11860 {
11861 if (temp1)
11862 delete arg1;
11863 }
11864 return resultobj;
11865 fail:
11866 {
11867 if (temp1)
11868 delete arg1;
11869 }
11870 return NULL;
11871 }
11872
11873
11874 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11875 PyObject *resultobj = 0;
11876 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11877 wxString *arg2 = 0 ;
11878 bool result;
11879 void *argp1 = 0 ;
11880 int res1 = 0 ;
11881 bool temp2 = false ;
11882 PyObject * obj0 = 0 ;
11883 PyObject * obj1 = 0 ;
11884 char * kwnames[] = {
11885 (char *) "self",(char *) "location", NULL
11886 };
11887
11888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11890 if (!SWIG_IsOK(res1)) {
11891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11892 }
11893 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11894 {
11895 arg2 = wxString_in_helper(obj1);
11896 if (arg2 == NULL) SWIG_fail;
11897 temp2 = true;
11898 }
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11902 wxPyEndAllowThreads(__tstate);
11903 if (PyErr_Occurred()) SWIG_fail;
11904 }
11905 {
11906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11907 }
11908 {
11909 if (temp2)
11910 delete arg2;
11911 }
11912 return resultobj;
11913 fail:
11914 {
11915 if (temp2)
11916 delete arg2;
11917 }
11918 return NULL;
11919 }
11920
11921
11922 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11923 PyObject *resultobj = 0;
11924 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11925 wxFileSystem *arg2 = 0 ;
11926 wxString *arg3 = 0 ;
11927 wxFSFile *result = 0 ;
11928 void *argp1 = 0 ;
11929 int res1 = 0 ;
11930 void *argp2 = 0 ;
11931 int res2 = 0 ;
11932 bool temp3 = false ;
11933 PyObject * obj0 = 0 ;
11934 PyObject * obj1 = 0 ;
11935 PyObject * obj2 = 0 ;
11936 char * kwnames[] = {
11937 (char *) "self",(char *) "fs",(char *) "location", NULL
11938 };
11939
11940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11944 }
11945 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11946 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11947 if (!SWIG_IsOK(res2)) {
11948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11949 }
11950 if (!argp2) {
11951 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11952 }
11953 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11954 {
11955 arg3 = wxString_in_helper(obj2);
11956 if (arg3 == NULL) SWIG_fail;
11957 temp3 = true;
11958 }
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11962 wxPyEndAllowThreads(__tstate);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 {
11966 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11967 }
11968 {
11969 if (temp3)
11970 delete arg3;
11971 }
11972 return resultobj;
11973 fail:
11974 {
11975 if (temp3)
11976 delete arg3;
11977 }
11978 return NULL;
11979 }
11980
11981
11982 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11983 PyObject *resultobj = 0;
11984 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11985 wxString *arg2 = 0 ;
11986 int arg3 = (int) 0 ;
11987 wxString result;
11988 void *argp1 = 0 ;
11989 int res1 = 0 ;
11990 bool temp2 = false ;
11991 int val3 ;
11992 int ecode3 = 0 ;
11993 PyObject * obj0 = 0 ;
11994 PyObject * obj1 = 0 ;
11995 PyObject * obj2 = 0 ;
11996 char * kwnames[] = {
11997 (char *) "self",(char *) "spec",(char *) "flags", NULL
11998 };
11999
12000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12002 if (!SWIG_IsOK(res1)) {
12003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12004 }
12005 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12006 {
12007 arg2 = wxString_in_helper(obj1);
12008 if (arg2 == NULL) SWIG_fail;
12009 temp2 = true;
12010 }
12011 if (obj2) {
12012 ecode3 = SWIG_AsVal_int(obj2, &val3);
12013 if (!SWIG_IsOK(ecode3)) {
12014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12015 }
12016 arg3 = static_cast< int >(val3);
12017 }
12018 {
12019 PyThreadState* __tstate = wxPyBeginAllowThreads();
12020 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12021 wxPyEndAllowThreads(__tstate);
12022 if (PyErr_Occurred()) SWIG_fail;
12023 }
12024 {
12025 #if wxUSE_UNICODE
12026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12027 #else
12028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12029 #endif
12030 }
12031 {
12032 if (temp2)
12033 delete arg2;
12034 }
12035 return resultobj;
12036 fail:
12037 {
12038 if (temp2)
12039 delete arg2;
12040 }
12041 return NULL;
12042 }
12043
12044
12045 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12046 PyObject *resultobj = 0;
12047 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12048 wxString result;
12049 void *argp1 = 0 ;
12050 int res1 = 0 ;
12051 PyObject *swig_obj[1] ;
12052
12053 if (!args) SWIG_fail;
12054 swig_obj[0] = args;
12055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12056 if (!SWIG_IsOK(res1)) {
12057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12058 }
12059 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (arg1)->FindNext();
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 {
12067 #if wxUSE_UNICODE
12068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12069 #else
12070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12071 #endif
12072 }
12073 return resultobj;
12074 fail:
12075 return NULL;
12076 }
12077
12078
12079 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 PyObject *obj;
12081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12082 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12083 return SWIG_Py_Void();
12084 }
12085
12086 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12087 return SWIG_Python_InitShadowInstance(args);
12088 }
12089
12090 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *resultobj = 0;
12092 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12093 wxString result;
12094 void *argp1 = 0 ;
12095 int res1 = 0 ;
12096 PyObject *swig_obj[1] ;
12097
12098 if (!args) SWIG_fail;
12099 swig_obj[0] = args;
12100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12101 if (!SWIG_IsOK(res1)) {
12102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12103 }
12104 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (arg1)->GetName();
12108 wxPyEndAllowThreads(__tstate);
12109 if (PyErr_Occurred()) SWIG_fail;
12110 }
12111 {
12112 #if wxUSE_UNICODE
12113 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12114 #else
12115 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12116 #endif
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12125 PyObject *resultobj = 0;
12126 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12127 wxString result;
12128 void *argp1 = 0 ;
12129 int res1 = 0 ;
12130 PyObject *swig_obj[1] ;
12131
12132 if (!args) SWIG_fail;
12133 swig_obj[0] = args;
12134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12135 if (!SWIG_IsOK(res1)) {
12136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12137 }
12138 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12139 {
12140 PyThreadState* __tstate = wxPyBeginAllowThreads();
12141 result = (arg1)->GetExtension();
12142 wxPyEndAllowThreads(__tstate);
12143 if (PyErr_Occurred()) SWIG_fail;
12144 }
12145 {
12146 #if wxUSE_UNICODE
12147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12148 #else
12149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12150 #endif
12151 }
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12159 PyObject *resultobj = 0;
12160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12161 long result;
12162 void *argp1 = 0 ;
12163 int res1 = 0 ;
12164 PyObject *swig_obj[1] ;
12165
12166 if (!args) SWIG_fail;
12167 swig_obj[0] = args;
12168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12171 }
12172 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (long)(arg1)->GetType();
12176 wxPyEndAllowThreads(__tstate);
12177 if (PyErr_Occurred()) SWIG_fail;
12178 }
12179 resultobj = SWIG_From_long(static_cast< long >(result));
12180 return resultobj;
12181 fail:
12182 return NULL;
12183 }
12184
12185
12186 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12187 PyObject *resultobj = 0;
12188 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12189 wxString result;
12190 void *argp1 = 0 ;
12191 int res1 = 0 ;
12192 PyObject *swig_obj[1] ;
12193
12194 if (!args) SWIG_fail;
12195 swig_obj[0] = args;
12196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12197 if (!SWIG_IsOK(res1)) {
12198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12199 }
12200 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (arg1)->GetMimeType();
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 {
12208 #if wxUSE_UNICODE
12209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12210 #else
12211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12212 #endif
12213 }
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12221 PyObject *resultobj = 0;
12222 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12223 wxString *arg2 = 0 ;
12224 bool result;
12225 void *argp1 = 0 ;
12226 int res1 = 0 ;
12227 bool temp2 = false ;
12228 PyObject * obj0 = 0 ;
12229 PyObject * obj1 = 0 ;
12230 char * kwnames[] = {
12231 (char *) "self",(char *) "name", NULL
12232 };
12233
12234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12236 if (!SWIG_IsOK(res1)) {
12237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12238 }
12239 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12240 {
12241 arg2 = wxString_in_helper(obj1);
12242 if (arg2 == NULL) SWIG_fail;
12243 temp2 = true;
12244 }
12245 {
12246 PyThreadState* __tstate = wxPyBeginAllowThreads();
12247 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12248 wxPyEndAllowThreads(__tstate);
12249 if (PyErr_Occurred()) SWIG_fail;
12250 }
12251 {
12252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12253 }
12254 {
12255 if (temp2)
12256 delete arg2;
12257 }
12258 return resultobj;
12259 fail:
12260 {
12261 if (temp2)
12262 delete arg2;
12263 }
12264 return NULL;
12265 }
12266
12267
12268 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12269 PyObject *resultobj = 0;
12270 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12271 wxInputStream *arg2 = 0 ;
12272 bool result;
12273 void *argp1 = 0 ;
12274 int res1 = 0 ;
12275 wxPyInputStream *temp2 ;
12276 bool created2 ;
12277 PyObject * obj0 = 0 ;
12278 PyObject * obj1 = 0 ;
12279 char * kwnames[] = {
12280 (char *) "self",(char *) "stream", NULL
12281 };
12282
12283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12285 if (!SWIG_IsOK(res1)) {
12286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12287 }
12288 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12289 {
12290 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12291 arg2 = temp2->m_wxis;
12292 created2 = false;
12293 } else {
12294 PyErr_Clear(); // clear the failure of the wxPyConvert above
12295 arg2 = wxPyCBInputStream_create(obj1, false);
12296 if (arg2 == NULL) {
12297 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12298 SWIG_fail;
12299 }
12300 created2 = true;
12301 }
12302 }
12303 {
12304 PyThreadState* __tstate = wxPyBeginAllowThreads();
12305 result = (bool)(arg1)->CanRead(*arg2);
12306 wxPyEndAllowThreads(__tstate);
12307 if (PyErr_Occurred()) SWIG_fail;
12308 }
12309 {
12310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12311 }
12312 {
12313 if (created2) delete arg2;
12314 }
12315 return resultobj;
12316 fail:
12317 {
12318 if (created2) delete arg2;
12319 }
12320 return NULL;
12321 }
12322
12323
12324 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12325 PyObject *resultobj = 0;
12326 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12327 wxString *arg2 = 0 ;
12328 void *argp1 = 0 ;
12329 int res1 = 0 ;
12330 bool temp2 = false ;
12331 PyObject * obj0 = 0 ;
12332 PyObject * obj1 = 0 ;
12333 char * kwnames[] = {
12334 (char *) "self",(char *) "name", NULL
12335 };
12336
12337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12341 }
12342 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12343 {
12344 arg2 = wxString_in_helper(obj1);
12345 if (arg2 == NULL) SWIG_fail;
12346 temp2 = true;
12347 }
12348 {
12349 PyThreadState* __tstate = wxPyBeginAllowThreads();
12350 (arg1)->SetName((wxString const &)*arg2);
12351 wxPyEndAllowThreads(__tstate);
12352 if (PyErr_Occurred()) SWIG_fail;
12353 }
12354 resultobj = SWIG_Py_Void();
12355 {
12356 if (temp2)
12357 delete arg2;
12358 }
12359 return resultobj;
12360 fail:
12361 {
12362 if (temp2)
12363 delete arg2;
12364 }
12365 return NULL;
12366 }
12367
12368
12369 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12370 PyObject *resultobj = 0;
12371 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12372 wxString *arg2 = 0 ;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 bool temp2 = false ;
12376 PyObject * obj0 = 0 ;
12377 PyObject * obj1 = 0 ;
12378 char * kwnames[] = {
12379 (char *) "self",(char *) "extension", NULL
12380 };
12381
12382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12386 }
12387 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12388 {
12389 arg2 = wxString_in_helper(obj1);
12390 if (arg2 == NULL) SWIG_fail;
12391 temp2 = true;
12392 }
12393 {
12394 PyThreadState* __tstate = wxPyBeginAllowThreads();
12395 (arg1)->SetExtension((wxString const &)*arg2);
12396 wxPyEndAllowThreads(__tstate);
12397 if (PyErr_Occurred()) SWIG_fail;
12398 }
12399 resultobj = SWIG_Py_Void();
12400 {
12401 if (temp2)
12402 delete arg2;
12403 }
12404 return resultobj;
12405 fail:
12406 {
12407 if (temp2)
12408 delete arg2;
12409 }
12410 return NULL;
12411 }
12412
12413
12414 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12415 PyObject *resultobj = 0;
12416 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12417 long arg2 ;
12418 void *argp1 = 0 ;
12419 int res1 = 0 ;
12420 long val2 ;
12421 int ecode2 = 0 ;
12422 PyObject * obj0 = 0 ;
12423 PyObject * obj1 = 0 ;
12424 char * kwnames[] = {
12425 (char *) "self",(char *) "type", NULL
12426 };
12427
12428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12430 if (!SWIG_IsOK(res1)) {
12431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12432 }
12433 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12434 ecode2 = SWIG_AsVal_long(obj1, &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12437 }
12438 arg2 = static_cast< long >(val2);
12439 {
12440 PyThreadState* __tstate = wxPyBeginAllowThreads();
12441 (arg1)->SetType(arg2);
12442 wxPyEndAllowThreads(__tstate);
12443 if (PyErr_Occurred()) SWIG_fail;
12444 }
12445 resultobj = SWIG_Py_Void();
12446 return resultobj;
12447 fail:
12448 return NULL;
12449 }
12450
12451
12452 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12453 PyObject *resultobj = 0;
12454 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12455 wxString *arg2 = 0 ;
12456 void *argp1 = 0 ;
12457 int res1 = 0 ;
12458 bool temp2 = false ;
12459 PyObject * obj0 = 0 ;
12460 PyObject * obj1 = 0 ;
12461 char * kwnames[] = {
12462 (char *) "self",(char *) "mimetype", NULL
12463 };
12464
12465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12467 if (!SWIG_IsOK(res1)) {
12468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12469 }
12470 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12471 {
12472 arg2 = wxString_in_helper(obj1);
12473 if (arg2 == NULL) SWIG_fail;
12474 temp2 = true;
12475 }
12476 {
12477 PyThreadState* __tstate = wxPyBeginAllowThreads();
12478 (arg1)->SetMimeType((wxString const &)*arg2);
12479 wxPyEndAllowThreads(__tstate);
12480 if (PyErr_Occurred()) SWIG_fail;
12481 }
12482 resultobj = SWIG_Py_Void();
12483 {
12484 if (temp2)
12485 delete arg2;
12486 }
12487 return resultobj;
12488 fail:
12489 {
12490 if (temp2)
12491 delete arg2;
12492 }
12493 return NULL;
12494 }
12495
12496
12497 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12498 PyObject *obj;
12499 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12500 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12501 return SWIG_Py_Void();
12502 }
12503
12504 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12505 PyObject *resultobj = 0;
12506 wxPyImageHandler *result = 0 ;
12507
12508 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (wxPyImageHandler *)new wxPyImageHandler();
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12525 PyObject *arg2 = (PyObject *) 0 ;
12526 void *argp1 = 0 ;
12527 int res1 = 0 ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char * kwnames[] = {
12531 (char *) "self",(char *) "self", NULL
12532 };
12533
12534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12538 }
12539 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12540 arg2 = obj1;
12541 {
12542 PyThreadState* __tstate = wxPyBeginAllowThreads();
12543 (arg1)->_SetSelf(arg2);
12544 wxPyEndAllowThreads(__tstate);
12545 if (PyErr_Occurred()) SWIG_fail;
12546 }
12547 resultobj = SWIG_Py_Void();
12548 return resultobj;
12549 fail:
12550 return NULL;
12551 }
12552
12553
12554 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12555 PyObject *obj;
12556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12557 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12558 return SWIG_Py_Void();
12559 }
12560
12561 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12562 return SWIG_Python_InitShadowInstance(args);
12563 }
12564
12565 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *resultobj = 0;
12567 wxImageHistogram *result = 0 ;
12568
12569 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12570 {
12571 PyThreadState* __tstate = wxPyBeginAllowThreads();
12572 result = (wxImageHistogram *)new wxImageHistogram();
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12577 return resultobj;
12578 fail:
12579 return NULL;
12580 }
12581
12582
12583 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12584 PyObject *resultobj = 0;
12585 byte arg1 ;
12586 byte arg2 ;
12587 byte arg3 ;
12588 unsigned long result;
12589 unsigned char val1 ;
12590 int ecode1 = 0 ;
12591 unsigned char val2 ;
12592 int ecode2 = 0 ;
12593 unsigned char val3 ;
12594 int ecode3 = 0 ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 PyObject * obj2 = 0 ;
12598 char * kwnames[] = {
12599 (char *) "r",(char *) "g",(char *) "b", NULL
12600 };
12601
12602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12603 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12604 if (!SWIG_IsOK(ecode1)) {
12605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12606 }
12607 arg1 = static_cast< byte >(val1);
12608 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12609 if (!SWIG_IsOK(ecode2)) {
12610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12611 }
12612 arg2 = static_cast< byte >(val2);
12613 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12614 if (!SWIG_IsOK(ecode3)) {
12615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12616 }
12617 arg3 = static_cast< byte >(val3);
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12625 return resultobj;
12626 fail:
12627 return NULL;
12628 }
12629
12630
12631 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12632 PyObject *resultobj = 0;
12633 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12634 byte *arg2 = (byte *) 0 ;
12635 byte *arg3 = (byte *) 0 ;
12636 byte *arg4 = (byte *) 0 ;
12637 byte arg5 = (byte) 1 ;
12638 byte arg6 = (byte) 0 ;
12639 byte arg7 = (byte) 0 ;
12640 bool result;
12641 void *argp1 = 0 ;
12642 int res1 = 0 ;
12643 byte temp2 ;
12644 int res2 = SWIG_TMPOBJ ;
12645 byte temp3 ;
12646 int res3 = SWIG_TMPOBJ ;
12647 byte temp4 ;
12648 int res4 = SWIG_TMPOBJ ;
12649 unsigned char val5 ;
12650 int ecode5 = 0 ;
12651 unsigned char val6 ;
12652 int ecode6 = 0 ;
12653 unsigned char val7 ;
12654 int ecode7 = 0 ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 PyObject * obj3 = 0 ;
12659 char * kwnames[] = {
12660 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12661 };
12662
12663 arg2 = &temp2;
12664 arg3 = &temp3;
12665 arg4 = &temp4;
12666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12668 if (!SWIG_IsOK(res1)) {
12669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12670 }
12671 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12672 if (obj1) {
12673 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12674 if (!SWIG_IsOK(ecode5)) {
12675 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12676 }
12677 arg5 = static_cast< byte >(val5);
12678 }
12679 if (obj2) {
12680 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12681 if (!SWIG_IsOK(ecode6)) {
12682 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12683 }
12684 arg6 = static_cast< byte >(val6);
12685 }
12686 if (obj3) {
12687 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12688 if (!SWIG_IsOK(ecode7)) {
12689 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12690 }
12691 arg7 = static_cast< byte >(val7);
12692 }
12693 {
12694 PyThreadState* __tstate = wxPyBeginAllowThreads();
12695 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12696 wxPyEndAllowThreads(__tstate);
12697 if (PyErr_Occurred()) SWIG_fail;
12698 }
12699 {
12700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12701 }
12702 if (SWIG_IsTmpObj(res2)) {
12703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12704 } else {
12705 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12707 }
12708 if (SWIG_IsTmpObj(res3)) {
12709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12710 } else {
12711 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12713 }
12714 if (SWIG_IsTmpObj(res4)) {
12715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12716 } else {
12717 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12719 }
12720 return resultobj;
12721 fail:
12722 return NULL;
12723 }
12724
12725
12726 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12727 PyObject *resultobj = 0;
12728 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12729 unsigned long arg2 ;
12730 unsigned long result;
12731 void *argp1 = 0 ;
12732 int res1 = 0 ;
12733 unsigned long val2 ;
12734 int ecode2 = 0 ;
12735 PyObject * obj0 = 0 ;
12736 PyObject * obj1 = 0 ;
12737 char * kwnames[] = {
12738 (char *) "self",(char *) "key", NULL
12739 };
12740
12741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12743 if (!SWIG_IsOK(res1)) {
12744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12745 }
12746 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12747 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12748 if (!SWIG_IsOK(ecode2)) {
12749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12750 }
12751 arg2 = static_cast< unsigned long >(val2);
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12755 wxPyEndAllowThreads(__tstate);
12756 if (PyErr_Occurred()) SWIG_fail;
12757 }
12758 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj = 0;
12767 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12768 byte arg2 ;
12769 byte arg3 ;
12770 byte arg4 ;
12771 unsigned long result;
12772 void *argp1 = 0 ;
12773 int res1 = 0 ;
12774 unsigned char val2 ;
12775 int ecode2 = 0 ;
12776 unsigned char val3 ;
12777 int ecode3 = 0 ;
12778 unsigned char val4 ;
12779 int ecode4 = 0 ;
12780 PyObject * obj0 = 0 ;
12781 PyObject * obj1 = 0 ;
12782 PyObject * obj2 = 0 ;
12783 PyObject * obj3 = 0 ;
12784 char * kwnames[] = {
12785 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12786 };
12787
12788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12790 if (!SWIG_IsOK(res1)) {
12791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12792 }
12793 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12794 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12795 if (!SWIG_IsOK(ecode2)) {
12796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12797 }
12798 arg2 = static_cast< byte >(val2);
12799 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12800 if (!SWIG_IsOK(ecode3)) {
12801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12802 }
12803 arg3 = static_cast< byte >(val3);
12804 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12805 if (!SWIG_IsOK(ecode4)) {
12806 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12807 }
12808 arg4 = static_cast< byte >(val4);
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj = 0;
12824 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12825 wxColour *arg2 = 0 ;
12826 unsigned long result;
12827 void *argp1 = 0 ;
12828 int res1 = 0 ;
12829 wxColour temp2 ;
12830 PyObject * obj0 = 0 ;
12831 PyObject * obj1 = 0 ;
12832 char * kwnames[] = {
12833 (char *) "self",(char *) "colour", NULL
12834 };
12835
12836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12838 if (!SWIG_IsOK(res1)) {
12839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12840 }
12841 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12842 {
12843 arg2 = &temp2;
12844 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12845 }
12846 {
12847 PyThreadState* __tstate = wxPyBeginAllowThreads();
12848 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12849 wxPyEndAllowThreads(__tstate);
12850 if (PyErr_Occurred()) SWIG_fail;
12851 }
12852 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12853 return resultobj;
12854 fail:
12855 return NULL;
12856 }
12857
12858
12859 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12860 PyObject *obj;
12861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12862 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12863 return SWIG_Py_Void();
12864 }
12865
12866 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12867 return SWIG_Python_InitShadowInstance(args);
12868 }
12869
12870 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12871 PyObject *resultobj = 0;
12872 byte arg1 = (byte) 0 ;
12873 byte arg2 = (byte) 0 ;
12874 byte arg3 = (byte) 0 ;
12875 wxImage_RGBValue *result = 0 ;
12876 unsigned char val1 ;
12877 int ecode1 = 0 ;
12878 unsigned char val2 ;
12879 int ecode2 = 0 ;
12880 unsigned char val3 ;
12881 int ecode3 = 0 ;
12882 PyObject * obj0 = 0 ;
12883 PyObject * obj1 = 0 ;
12884 PyObject * obj2 = 0 ;
12885 char * kwnames[] = {
12886 (char *) "r",(char *) "g",(char *) "b", NULL
12887 };
12888
12889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12890 if (obj0) {
12891 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12892 if (!SWIG_IsOK(ecode1)) {
12893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12894 }
12895 arg1 = static_cast< byte >(val1);
12896 }
12897 if (obj1) {
12898 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12899 if (!SWIG_IsOK(ecode2)) {
12900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12901 }
12902 arg2 = static_cast< byte >(val2);
12903 }
12904 if (obj2) {
12905 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12906 if (!SWIG_IsOK(ecode3)) {
12907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12908 }
12909 arg3 = static_cast< byte >(val3);
12910 }
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12918 return resultobj;
12919 fail:
12920 return NULL;
12921 }
12922
12923
12924 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12925 PyObject *resultobj = 0;
12926 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12927 byte arg2 ;
12928 void *argp1 = 0 ;
12929 int res1 = 0 ;
12930 unsigned char val2 ;
12931 int ecode2 = 0 ;
12932 PyObject *swig_obj[2] ;
12933
12934 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12936 if (!SWIG_IsOK(res1)) {
12937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12938 }
12939 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12940 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12941 if (!SWIG_IsOK(ecode2)) {
12942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12943 }
12944 arg2 = static_cast< byte >(val2);
12945 if (arg1) (arg1)->red = arg2;
12946
12947 resultobj = SWIG_Py_Void();
12948 return resultobj;
12949 fail:
12950 return NULL;
12951 }
12952
12953
12954 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12955 PyObject *resultobj = 0;
12956 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12957 byte result;
12958 void *argp1 = 0 ;
12959 int res1 = 0 ;
12960 PyObject *swig_obj[1] ;
12961
12962 if (!args) SWIG_fail;
12963 swig_obj[0] = args;
12964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12965 if (!SWIG_IsOK(res1)) {
12966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12967 }
12968 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12969 result = (byte) ((arg1)->red);
12970 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12971 return resultobj;
12972 fail:
12973 return NULL;
12974 }
12975
12976
12977 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12978 PyObject *resultobj = 0;
12979 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12980 byte arg2 ;
12981 void *argp1 = 0 ;
12982 int res1 = 0 ;
12983 unsigned char val2 ;
12984 int ecode2 = 0 ;
12985 PyObject *swig_obj[2] ;
12986
12987 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12989 if (!SWIG_IsOK(res1)) {
12990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12991 }
12992 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12993 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12994 if (!SWIG_IsOK(ecode2)) {
12995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12996 }
12997 arg2 = static_cast< byte >(val2);
12998 if (arg1) (arg1)->green = arg2;
12999
13000 resultobj = SWIG_Py_Void();
13001 return resultobj;
13002 fail:
13003 return NULL;
13004 }
13005
13006
13007 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13008 PyObject *resultobj = 0;
13009 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13010 byte result;
13011 void *argp1 = 0 ;
13012 int res1 = 0 ;
13013 PyObject *swig_obj[1] ;
13014
13015 if (!args) SWIG_fail;
13016 swig_obj[0] = args;
13017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13018 if (!SWIG_IsOK(res1)) {
13019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13020 }
13021 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13022 result = (byte) ((arg1)->green);
13023 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13031 PyObject *resultobj = 0;
13032 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13033 byte arg2 ;
13034 void *argp1 = 0 ;
13035 int res1 = 0 ;
13036 unsigned char val2 ;
13037 int ecode2 = 0 ;
13038 PyObject *swig_obj[2] ;
13039
13040 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13042 if (!SWIG_IsOK(res1)) {
13043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13044 }
13045 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13046 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13047 if (!SWIG_IsOK(ecode2)) {
13048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13049 }
13050 arg2 = static_cast< byte >(val2);
13051 if (arg1) (arg1)->blue = arg2;
13052
13053 resultobj = SWIG_Py_Void();
13054 return resultobj;
13055 fail:
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13061 PyObject *resultobj = 0;
13062 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13063 byte result;
13064 void *argp1 = 0 ;
13065 int res1 = 0 ;
13066 PyObject *swig_obj[1] ;
13067
13068 if (!args) SWIG_fail;
13069 swig_obj[0] = args;
13070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13071 if (!SWIG_IsOK(res1)) {
13072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13073 }
13074 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13075 result = (byte) ((arg1)->blue);
13076 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *obj;
13085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13086 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13087 return SWIG_Py_Void();
13088 }
13089
13090 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13091 return SWIG_Python_InitShadowInstance(args);
13092 }
13093
13094 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13095 PyObject *resultobj = 0;
13096 double arg1 = (double) 0.0 ;
13097 double arg2 = (double) 0.0 ;
13098 double arg3 = (double) 0.0 ;
13099 wxImage_HSVValue *result = 0 ;
13100 double val1 ;
13101 int ecode1 = 0 ;
13102 double val2 ;
13103 int ecode2 = 0 ;
13104 double val3 ;
13105 int ecode3 = 0 ;
13106 PyObject * obj0 = 0 ;
13107 PyObject * obj1 = 0 ;
13108 PyObject * obj2 = 0 ;
13109 char * kwnames[] = {
13110 (char *) "h",(char *) "s",(char *) "v", NULL
13111 };
13112
13113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13114 if (obj0) {
13115 ecode1 = SWIG_AsVal_double(obj0, &val1);
13116 if (!SWIG_IsOK(ecode1)) {
13117 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13118 }
13119 arg1 = static_cast< double >(val1);
13120 }
13121 if (obj1) {
13122 ecode2 = SWIG_AsVal_double(obj1, &val2);
13123 if (!SWIG_IsOK(ecode2)) {
13124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13125 }
13126 arg2 = static_cast< double >(val2);
13127 }
13128 if (obj2) {
13129 ecode3 = SWIG_AsVal_double(obj2, &val3);
13130 if (!SWIG_IsOK(ecode3)) {
13131 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13132 }
13133 arg3 = static_cast< double >(val3);
13134 }
13135 {
13136 PyThreadState* __tstate = wxPyBeginAllowThreads();
13137 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13149 PyObject *resultobj = 0;
13150 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13151 double arg2 ;
13152 void *argp1 = 0 ;
13153 int res1 = 0 ;
13154 double val2 ;
13155 int ecode2 = 0 ;
13156 PyObject *swig_obj[2] ;
13157
13158 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13162 }
13163 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13164 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13165 if (!SWIG_IsOK(ecode2)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13167 }
13168 arg2 = static_cast< double >(val2);
13169 if (arg1) (arg1)->hue = arg2;
13170
13171 resultobj = SWIG_Py_Void();
13172 return resultobj;
13173 fail:
13174 return NULL;
13175 }
13176
13177
13178 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13179 PyObject *resultobj = 0;
13180 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13181 double result;
13182 void *argp1 = 0 ;
13183 int res1 = 0 ;
13184 PyObject *swig_obj[1] ;
13185
13186 if (!args) SWIG_fail;
13187 swig_obj[0] = args;
13188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13189 if (!SWIG_IsOK(res1)) {
13190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13191 }
13192 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13193 result = (double) ((arg1)->hue);
13194 resultobj = SWIG_From_double(static_cast< double >(result));
13195 return resultobj;
13196 fail:
13197 return NULL;
13198 }
13199
13200
13201 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13202 PyObject *resultobj = 0;
13203 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13204 double arg2 ;
13205 void *argp1 = 0 ;
13206 int res1 = 0 ;
13207 double val2 ;
13208 int ecode2 = 0 ;
13209 PyObject *swig_obj[2] ;
13210
13211 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13213 if (!SWIG_IsOK(res1)) {
13214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13215 }
13216 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13217 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13218 if (!SWIG_IsOK(ecode2)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13220 }
13221 arg2 = static_cast< double >(val2);
13222 if (arg1) (arg1)->saturation = arg2;
13223
13224 resultobj = SWIG_Py_Void();
13225 return resultobj;
13226 fail:
13227 return NULL;
13228 }
13229
13230
13231 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13232 PyObject *resultobj = 0;
13233 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13234 double result;
13235 void *argp1 = 0 ;
13236 int res1 = 0 ;
13237 PyObject *swig_obj[1] ;
13238
13239 if (!args) SWIG_fail;
13240 swig_obj[0] = args;
13241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13242 if (!SWIG_IsOK(res1)) {
13243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13244 }
13245 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13246 result = (double) ((arg1)->saturation);
13247 resultobj = SWIG_From_double(static_cast< double >(result));
13248 return resultobj;
13249 fail:
13250 return NULL;
13251 }
13252
13253
13254 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13255 PyObject *resultobj = 0;
13256 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13257 double arg2 ;
13258 void *argp1 = 0 ;
13259 int res1 = 0 ;
13260 double val2 ;
13261 int ecode2 = 0 ;
13262 PyObject *swig_obj[2] ;
13263
13264 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13266 if (!SWIG_IsOK(res1)) {
13267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13268 }
13269 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13270 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13271 if (!SWIG_IsOK(ecode2)) {
13272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13273 }
13274 arg2 = static_cast< double >(val2);
13275 if (arg1) (arg1)->value = arg2;
13276
13277 resultobj = SWIG_Py_Void();
13278 return resultobj;
13279 fail:
13280 return NULL;
13281 }
13282
13283
13284 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13285 PyObject *resultobj = 0;
13286 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13287 double result;
13288 void *argp1 = 0 ;
13289 int res1 = 0 ;
13290 PyObject *swig_obj[1] ;
13291
13292 if (!args) SWIG_fail;
13293 swig_obj[0] = args;
13294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13295 if (!SWIG_IsOK(res1)) {
13296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13297 }
13298 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13299 result = (double) ((arg1)->value);
13300 resultobj = SWIG_From_double(static_cast< double >(result));
13301 return resultobj;
13302 fail:
13303 return NULL;
13304 }
13305
13306
13307 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13308 PyObject *obj;
13309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13310 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13311 return SWIG_Py_Void();
13312 }
13313
13314 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315 return SWIG_Python_InitShadowInstance(args);
13316 }
13317
13318 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj = 0;
13320 wxString *arg1 = 0 ;
13321 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13322 int arg3 = (int) -1 ;
13323 wxImage *result = 0 ;
13324 bool temp1 = false ;
13325 long val2 ;
13326 int ecode2 = 0 ;
13327 int val3 ;
13328 int ecode3 = 0 ;
13329 PyObject * obj0 = 0 ;
13330 PyObject * obj1 = 0 ;
13331 PyObject * obj2 = 0 ;
13332 char * kwnames[] = {
13333 (char *) "name",(char *) "type",(char *) "index", NULL
13334 };
13335
13336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13337 {
13338 arg1 = wxString_in_helper(obj0);
13339 if (arg1 == NULL) SWIG_fail;
13340 temp1 = true;
13341 }
13342 if (obj1) {
13343 ecode2 = SWIG_AsVal_long(obj1, &val2);
13344 if (!SWIG_IsOK(ecode2)) {
13345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13346 }
13347 arg2 = static_cast< long >(val2);
13348 }
13349 if (obj2) {
13350 ecode3 = SWIG_AsVal_int(obj2, &val3);
13351 if (!SWIG_IsOK(ecode3)) {
13352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13353 }
13354 arg3 = static_cast< int >(val3);
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13359 wxPyEndAllowThreads(__tstate);
13360 if (PyErr_Occurred()) SWIG_fail;
13361 }
13362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13363 {
13364 if (temp1)
13365 delete arg1;
13366 }
13367 return resultobj;
13368 fail:
13369 {
13370 if (temp1)
13371 delete arg1;
13372 }
13373 return NULL;
13374 }
13375
13376
13377 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13378 PyObject *resultobj = 0;
13379 wxImage *arg1 = (wxImage *) 0 ;
13380 void *argp1 = 0 ;
13381 int res1 = 0 ;
13382 PyObject *swig_obj[1] ;
13383
13384 if (!args) SWIG_fail;
13385 swig_obj[0] = args;
13386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13387 if (!SWIG_IsOK(res1)) {
13388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13389 }
13390 arg1 = reinterpret_cast< wxImage * >(argp1);
13391 {
13392 PyThreadState* __tstate = wxPyBeginAllowThreads();
13393 delete arg1;
13394
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 resultobj = SWIG_Py_Void();
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13406 PyObject *resultobj = 0;
13407 wxString *arg1 = 0 ;
13408 wxString *arg2 = 0 ;
13409 int arg3 = (int) -1 ;
13410 wxImage *result = 0 ;
13411 bool temp1 = false ;
13412 bool temp2 = false ;
13413 int val3 ;
13414 int ecode3 = 0 ;
13415 PyObject * obj0 = 0 ;
13416 PyObject * obj1 = 0 ;
13417 PyObject * obj2 = 0 ;
13418 char * kwnames[] = {
13419 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13420 };
13421
13422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13423 {
13424 arg1 = wxString_in_helper(obj0);
13425 if (arg1 == NULL) SWIG_fail;
13426 temp1 = true;
13427 }
13428 {
13429 arg2 = wxString_in_helper(obj1);
13430 if (arg2 == NULL) SWIG_fail;
13431 temp2 = true;
13432 }
13433 if (obj2) {
13434 ecode3 = SWIG_AsVal_int(obj2, &val3);
13435 if (!SWIG_IsOK(ecode3)) {
13436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13437 }
13438 arg3 = static_cast< int >(val3);
13439 }
13440 {
13441 PyThreadState* __tstate = wxPyBeginAllowThreads();
13442 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13447 {
13448 if (temp1)
13449 delete arg1;
13450 }
13451 {
13452 if (temp2)
13453 delete arg2;
13454 }
13455 return resultobj;
13456 fail:
13457 {
13458 if (temp1)
13459 delete arg1;
13460 }
13461 {
13462 if (temp2)
13463 delete arg2;
13464 }
13465 return NULL;
13466 }
13467
13468
13469 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13470 PyObject *resultobj = 0;
13471 wxInputStream *arg1 = 0 ;
13472 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13473 int arg3 = (int) -1 ;
13474 wxImage *result = 0 ;
13475 wxPyInputStream *temp1 ;
13476 bool created1 ;
13477 long val2 ;
13478 int ecode2 = 0 ;
13479 int val3 ;
13480 int ecode3 = 0 ;
13481 PyObject * obj0 = 0 ;
13482 PyObject * obj1 = 0 ;
13483 PyObject * obj2 = 0 ;
13484 char * kwnames[] = {
13485 (char *) "stream",(char *) "type",(char *) "index", NULL
13486 };
13487
13488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13489 {
13490 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13491 arg1 = temp1->m_wxis;
13492 created1 = false;
13493 } else {
13494 PyErr_Clear(); // clear the failure of the wxPyConvert above
13495 arg1 = wxPyCBInputStream_create(obj0, false);
13496 if (arg1 == NULL) {
13497 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13498 SWIG_fail;
13499 }
13500 created1 = true;
13501 }
13502 }
13503 if (obj1) {
13504 ecode2 = SWIG_AsVal_long(obj1, &val2);
13505 if (!SWIG_IsOK(ecode2)) {
13506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13507 }
13508 arg2 = static_cast< long >(val2);
13509 }
13510 if (obj2) {
13511 ecode3 = SWIG_AsVal_int(obj2, &val3);
13512 if (!SWIG_IsOK(ecode3)) {
13513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13514 }
13515 arg3 = static_cast< int >(val3);
13516 }
13517 {
13518 PyThreadState* __tstate = wxPyBeginAllowThreads();
13519 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13524 {
13525 if (created1) delete arg1;
13526 }
13527 return resultobj;
13528 fail:
13529 {
13530 if (created1) delete arg1;
13531 }
13532 return NULL;
13533 }
13534
13535
13536 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13537 PyObject *resultobj = 0;
13538 wxInputStream *arg1 = 0 ;
13539 wxString *arg2 = 0 ;
13540 int arg3 = (int) -1 ;
13541 wxImage *result = 0 ;
13542 wxPyInputStream *temp1 ;
13543 bool created1 ;
13544 bool temp2 = false ;
13545 int val3 ;
13546 int ecode3 = 0 ;
13547 PyObject * obj0 = 0 ;
13548 PyObject * obj1 = 0 ;
13549 PyObject * obj2 = 0 ;
13550 char * kwnames[] = {
13551 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13552 };
13553
13554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13555 {
13556 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13557 arg1 = temp1->m_wxis;
13558 created1 = false;
13559 } else {
13560 PyErr_Clear(); // clear the failure of the wxPyConvert above
13561 arg1 = wxPyCBInputStream_create(obj0, false);
13562 if (arg1 == NULL) {
13563 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13564 SWIG_fail;
13565 }
13566 created1 = true;
13567 }
13568 }
13569 {
13570 arg2 = wxString_in_helper(obj1);
13571 if (arg2 == NULL) SWIG_fail;
13572 temp2 = true;
13573 }
13574 if (obj2) {
13575 ecode3 = SWIG_AsVal_int(obj2, &val3);
13576 if (!SWIG_IsOK(ecode3)) {
13577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13578 }
13579 arg3 = static_cast< int >(val3);
13580 }
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13588 {
13589 if (created1) delete arg1;
13590 }
13591 {
13592 if (temp2)
13593 delete arg2;
13594 }
13595 return resultobj;
13596 fail:
13597 {
13598 if (created1) delete arg1;
13599 }
13600 {
13601 if (temp2)
13602 delete arg2;
13603 }
13604 return NULL;
13605 }
13606
13607
13608 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13609 PyObject *resultobj = 0;
13610 int arg1 = (int) 0 ;
13611 int arg2 = (int) 0 ;
13612 bool arg3 = (bool) true ;
13613 wxImage *result = 0 ;
13614 int val1 ;
13615 int ecode1 = 0 ;
13616 int val2 ;
13617 int ecode2 = 0 ;
13618 bool val3 ;
13619 int ecode3 = 0 ;
13620 PyObject * obj0 = 0 ;
13621 PyObject * obj1 = 0 ;
13622 PyObject * obj2 = 0 ;
13623 char * kwnames[] = {
13624 (char *) "width",(char *) "height",(char *) "clear", NULL
13625 };
13626
13627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13628 if (obj0) {
13629 ecode1 = SWIG_AsVal_int(obj0, &val1);
13630 if (!SWIG_IsOK(ecode1)) {
13631 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13632 }
13633 arg1 = static_cast< int >(val1);
13634 }
13635 if (obj1) {
13636 ecode2 = SWIG_AsVal_int(obj1, &val2);
13637 if (!SWIG_IsOK(ecode2)) {
13638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13639 }
13640 arg2 = static_cast< int >(val2);
13641 }
13642 if (obj2) {
13643 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13644 if (!SWIG_IsOK(ecode3)) {
13645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13646 }
13647 arg3 = static_cast< bool >(val3);
13648 }
13649 {
13650 PyThreadState* __tstate = wxPyBeginAllowThreads();
13651 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13652 wxPyEndAllowThreads(__tstate);
13653 if (PyErr_Occurred()) SWIG_fail;
13654 }
13655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13656 return resultobj;
13657 fail:
13658 return NULL;
13659 }
13660
13661
13662 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj = 0;
13664 wxBitmap *arg1 = 0 ;
13665 wxImage *result = 0 ;
13666 void *argp1 = 0 ;
13667 int res1 = 0 ;
13668 PyObject * obj0 = 0 ;
13669 char * kwnames[] = {
13670 (char *) "bitmap", NULL
13671 };
13672
13673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13674 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13675 if (!SWIG_IsOK(res1)) {
13676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13677 }
13678 if (!argp1) {
13679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13680 }
13681 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13682 {
13683 if (!wxPyCheckForApp()) SWIG_fail;
13684 PyThreadState* __tstate = wxPyBeginAllowThreads();
13685 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13686 wxPyEndAllowThreads(__tstate);
13687 if (PyErr_Occurred()) SWIG_fail;
13688 }
13689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13690 return resultobj;
13691 fail:
13692 return NULL;
13693 }
13694
13695
13696 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj = 0;
13698 int arg1 ;
13699 int arg2 ;
13700 buffer arg3 ;
13701 int arg4 ;
13702 wxImage *result = 0 ;
13703 int val1 ;
13704 int ecode1 = 0 ;
13705 int val2 ;
13706 int ecode2 = 0 ;
13707 Py_ssize_t temp3 ;
13708 PyObject * obj0 = 0 ;
13709 PyObject * obj1 = 0 ;
13710 PyObject * obj2 = 0 ;
13711 char * kwnames[] = {
13712 (char *) "width",(char *) "height",(char *) "data", NULL
13713 };
13714
13715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13716 ecode1 = SWIG_AsVal_int(obj0, &val1);
13717 if (!SWIG_IsOK(ecode1)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13719 }
13720 arg1 = static_cast< int >(val1);
13721 ecode2 = SWIG_AsVal_int(obj1, &val2);
13722 if (!SWIG_IsOK(ecode2)) {
13723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13724 }
13725 arg2 = static_cast< int >(val2);
13726 {
13727 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13728 arg4 = (int)temp3;
13729 }
13730 {
13731 PyThreadState* __tstate = wxPyBeginAllowThreads();
13732 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13733 wxPyEndAllowThreads(__tstate);
13734 if (PyErr_Occurred()) SWIG_fail;
13735 }
13736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13737 return resultobj;
13738 fail:
13739 return NULL;
13740 }
13741
13742
13743 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13744 PyObject *resultobj = 0;
13745 int arg1 ;
13746 int arg2 ;
13747 buffer arg3 ;
13748 int arg4 ;
13749 buffer arg5 ;
13750 int arg6 ;
13751 wxImage *result = 0 ;
13752 int val1 ;
13753 int ecode1 = 0 ;
13754 int val2 ;
13755 int ecode2 = 0 ;
13756 Py_ssize_t temp3 ;
13757 Py_ssize_t temp5 ;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 PyObject * obj3 = 0 ;
13762 char * kwnames[] = {
13763 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13764 };
13765
13766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13767 ecode1 = SWIG_AsVal_int(obj0, &val1);
13768 if (!SWIG_IsOK(ecode1)) {
13769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13770 }
13771 arg1 = static_cast< int >(val1);
13772 ecode2 = SWIG_AsVal_int(obj1, &val2);
13773 if (!SWIG_IsOK(ecode2)) {
13774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13775 }
13776 arg2 = static_cast< int >(val2);
13777 {
13778 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13779 arg4 = (int)temp3;
13780 }
13781 {
13782 if (obj3 != Py_None) {
13783 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13784 arg6 = (int)temp5;
13785 }
13786 }
13787 {
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj = 0;
13802 wxImage *arg1 = (wxImage *) 0 ;
13803 int arg2 ;
13804 int arg3 ;
13805 bool arg4 = (bool) true ;
13806 void *argp1 = 0 ;
13807 int res1 = 0 ;
13808 int val2 ;
13809 int ecode2 = 0 ;
13810 int val3 ;
13811 int ecode3 = 0 ;
13812 bool val4 ;
13813 int ecode4 = 0 ;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 PyObject * obj2 = 0 ;
13817 PyObject * obj3 = 0 ;
13818 char * kwnames[] = {
13819 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13820 };
13821
13822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13824 if (!SWIG_IsOK(res1)) {
13825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13826 }
13827 arg1 = reinterpret_cast< wxImage * >(argp1);
13828 ecode2 = SWIG_AsVal_int(obj1, &val2);
13829 if (!SWIG_IsOK(ecode2)) {
13830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13831 }
13832 arg2 = static_cast< int >(val2);
13833 ecode3 = SWIG_AsVal_int(obj2, &val3);
13834 if (!SWIG_IsOK(ecode3)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13836 }
13837 arg3 = static_cast< int >(val3);
13838 if (obj3) {
13839 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13840 if (!SWIG_IsOK(ecode4)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13842 }
13843 arg4 = static_cast< bool >(val4);
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 (arg1)->Create(arg2,arg3,arg4);
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 resultobj = SWIG_Py_Void();
13852 return resultobj;
13853 fail:
13854 return NULL;
13855 }
13856
13857
13858 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13859 PyObject *resultobj = 0;
13860 wxImage *arg1 = (wxImage *) 0 ;
13861 void *argp1 = 0 ;
13862 int res1 = 0 ;
13863 PyObject *swig_obj[1] ;
13864
13865 if (!args) SWIG_fail;
13866 swig_obj[0] = args;
13867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13868 if (!SWIG_IsOK(res1)) {
13869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13870 }
13871 arg1 = reinterpret_cast< wxImage * >(argp1);
13872 {
13873 PyThreadState* __tstate = wxPyBeginAllowThreads();
13874 (arg1)->Destroy();
13875 wxPyEndAllowThreads(__tstate);
13876 if (PyErr_Occurred()) SWIG_fail;
13877 }
13878 resultobj = SWIG_Py_Void();
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13886 PyObject *resultobj = 0;
13887 wxImage *arg1 = (wxImage *) 0 ;
13888 int arg2 ;
13889 int arg3 ;
13890 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13891 SwigValueWrapper<wxImage > result;
13892 void *argp1 = 0 ;
13893 int res1 = 0 ;
13894 int val2 ;
13895 int ecode2 = 0 ;
13896 int val3 ;
13897 int ecode3 = 0 ;
13898 int val4 ;
13899 int ecode4 = 0 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 PyObject * obj3 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 if (obj3) {
13925 ecode4 = SWIG_AsVal_int(obj3, &val4);
13926 if (!SWIG_IsOK(ecode4)) {
13927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13928 }
13929 arg4 = static_cast< int >(val4);
13930 }
13931 {
13932 PyThreadState* __tstate = wxPyBeginAllowThreads();
13933 result = (arg1)->Scale(arg2,arg3,arg4);
13934 wxPyEndAllowThreads(__tstate);
13935 if (PyErr_Occurred()) SWIG_fail;
13936 }
13937 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13938 return resultobj;
13939 fail:
13940 return NULL;
13941 }
13942
13943
13944 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13945 PyObject *resultobj = 0;
13946 wxImage *arg1 = (wxImage *) 0 ;
13947 int arg2 ;
13948 int arg3 ;
13949 SwigValueWrapper<wxImage > result;
13950 void *argp1 = 0 ;
13951 int res1 = 0 ;
13952 int val2 ;
13953 int ecode2 = 0 ;
13954 int val3 ;
13955 int ecode3 = 0 ;
13956 PyObject * obj0 = 0 ;
13957 PyObject * obj1 = 0 ;
13958 PyObject * obj2 = 0 ;
13959 char * kwnames[] = {
13960 (char *) "self",(char *) "width",(char *) "height", NULL
13961 };
13962
13963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13965 if (!SWIG_IsOK(res1)) {
13966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13967 }
13968 arg1 = reinterpret_cast< wxImage * >(argp1);
13969 ecode2 = SWIG_AsVal_int(obj1, &val2);
13970 if (!SWIG_IsOK(ecode2)) {
13971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13972 }
13973 arg2 = static_cast< int >(val2);
13974 ecode3 = SWIG_AsVal_int(obj2, &val3);
13975 if (!SWIG_IsOK(ecode3)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13977 }
13978 arg3 = static_cast< int >(val3);
13979 {
13980 PyThreadState* __tstate = wxPyBeginAllowThreads();
13981 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13982 wxPyEndAllowThreads(__tstate);
13983 if (PyErr_Occurred()) SWIG_fail;
13984 }
13985 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13986 return resultobj;
13987 fail:
13988 return NULL;
13989 }
13990
13991
13992 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13993 PyObject *resultobj = 0;
13994 wxImage *arg1 = (wxImage *) 0 ;
13995 int arg2 ;
13996 int arg3 ;
13997 SwigValueWrapper<wxImage > result;
13998 void *argp1 = 0 ;
13999 int res1 = 0 ;
14000 int val2 ;
14001 int ecode2 = 0 ;
14002 int val3 ;
14003 int ecode3 = 0 ;
14004 PyObject * obj0 = 0 ;
14005 PyObject * obj1 = 0 ;
14006 PyObject * obj2 = 0 ;
14007 char * kwnames[] = {
14008 (char *) "self",(char *) "width",(char *) "height", NULL
14009 };
14010
14011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14013 if (!SWIG_IsOK(res1)) {
14014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14015 }
14016 arg1 = reinterpret_cast< wxImage * >(argp1);
14017 ecode2 = SWIG_AsVal_int(obj1, &val2);
14018 if (!SWIG_IsOK(ecode2)) {
14019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14020 }
14021 arg2 = static_cast< int >(val2);
14022 ecode3 = SWIG_AsVal_int(obj2, &val3);
14023 if (!SWIG_IsOK(ecode3)) {
14024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14025 }
14026 arg3 = static_cast< int >(val3);
14027 {
14028 PyThreadState* __tstate = wxPyBeginAllowThreads();
14029 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14030 wxPyEndAllowThreads(__tstate);
14031 if (PyErr_Occurred()) SWIG_fail;
14032 }
14033 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14034 return resultobj;
14035 fail:
14036 return NULL;
14037 }
14038
14039
14040 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14041 PyObject *resultobj = 0;
14042 wxImage *arg1 = (wxImage *) 0 ;
14043 int arg2 ;
14044 SwigValueWrapper<wxImage > result;
14045 void *argp1 = 0 ;
14046 int res1 = 0 ;
14047 int val2 ;
14048 int ecode2 = 0 ;
14049 PyObject * obj0 = 0 ;
14050 PyObject * obj1 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "radius", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14059 }
14060 arg1 = reinterpret_cast< wxImage * >(argp1);
14061 ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14064 }
14065 arg2 = static_cast< int >(val2);
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 result = (arg1)->Blur(arg2);
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj = 0;
14081 wxImage *arg1 = (wxImage *) 0 ;
14082 int arg2 ;
14083 SwigValueWrapper<wxImage > result;
14084 void *argp1 = 0 ;
14085 int res1 = 0 ;
14086 int val2 ;
14087 int ecode2 = 0 ;
14088 PyObject * obj0 = 0 ;
14089 PyObject * obj1 = 0 ;
14090 char * kwnames[] = {
14091 (char *) "self",(char *) "radius", NULL
14092 };
14093
14094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14096 if (!SWIG_IsOK(res1)) {
14097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14098 }
14099 arg1 = reinterpret_cast< wxImage * >(argp1);
14100 ecode2 = SWIG_AsVal_int(obj1, &val2);
14101 if (!SWIG_IsOK(ecode2)) {
14102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14103 }
14104 arg2 = static_cast< int >(val2);
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 result = (arg1)->BlurHorizontal(arg2);
14108 wxPyEndAllowThreads(__tstate);
14109 if (PyErr_Occurred()) SWIG_fail;
14110 }
14111 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14112 return resultobj;
14113 fail:
14114 return NULL;
14115 }
14116
14117
14118 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14119 PyObject *resultobj = 0;
14120 wxImage *arg1 = (wxImage *) 0 ;
14121 int arg2 ;
14122 SwigValueWrapper<wxImage > result;
14123 void *argp1 = 0 ;
14124 int res1 = 0 ;
14125 int val2 ;
14126 int ecode2 = 0 ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 char * kwnames[] = {
14130 (char *) "self",(char *) "radius", NULL
14131 };
14132
14133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14135 if (!SWIG_IsOK(res1)) {
14136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14137 }
14138 arg1 = reinterpret_cast< wxImage * >(argp1);
14139 ecode2 = SWIG_AsVal_int(obj1, &val2);
14140 if (!SWIG_IsOK(ecode2)) {
14141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14142 }
14143 arg2 = static_cast< int >(val2);
14144 {
14145 PyThreadState* __tstate = wxPyBeginAllowThreads();
14146 result = (arg1)->BlurVertical(arg2);
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14151 return resultobj;
14152 fail:
14153 return NULL;
14154 }
14155
14156
14157 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14158 PyObject *resultobj = 0;
14159 wxImage *arg1 = (wxImage *) 0 ;
14160 int arg2 ;
14161 int arg3 ;
14162 SwigValueWrapper<wxImage > result;
14163 void *argp1 = 0 ;
14164 int res1 = 0 ;
14165 int val2 ;
14166 int ecode2 = 0 ;
14167 int val3 ;
14168 int ecode3 = 0 ;
14169 PyObject * obj0 = 0 ;
14170 PyObject * obj1 = 0 ;
14171 PyObject * obj2 = 0 ;
14172 char * kwnames[] = {
14173 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14174 };
14175
14176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14178 if (!SWIG_IsOK(res1)) {
14179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14180 }
14181 arg1 = reinterpret_cast< wxImage * >(argp1);
14182 ecode2 = SWIG_AsVal_int(obj1, &val2);
14183 if (!SWIG_IsOK(ecode2)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14185 }
14186 arg2 = static_cast< int >(val2);
14187 ecode3 = SWIG_AsVal_int(obj2, &val3);
14188 if (!SWIG_IsOK(ecode3)) {
14189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14190 }
14191 arg3 = static_cast< int >(val3);
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14195 wxPyEndAllowThreads(__tstate);
14196 if (PyErr_Occurred()) SWIG_fail;
14197 }
14198 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14199 return resultobj;
14200 fail:
14201 return NULL;
14202 }
14203
14204
14205 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj = 0;
14207 wxImage *arg1 = (wxImage *) 0 ;
14208 int arg2 ;
14209 int arg3 ;
14210 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14211 wxImage *result = 0 ;
14212 void *argp1 = 0 ;
14213 int res1 = 0 ;
14214 int val2 ;
14215 int ecode2 = 0 ;
14216 int val3 ;
14217 int ecode3 = 0 ;
14218 int val4 ;
14219 int ecode4 = 0 ;
14220 PyObject * obj0 = 0 ;
14221 PyObject * obj1 = 0 ;
14222 PyObject * obj2 = 0 ;
14223 PyObject * obj3 = 0 ;
14224 char * kwnames[] = {
14225 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14226 };
14227
14228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14230 if (!SWIG_IsOK(res1)) {
14231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14232 }
14233 arg1 = reinterpret_cast< wxImage * >(argp1);
14234 ecode2 = SWIG_AsVal_int(obj1, &val2);
14235 if (!SWIG_IsOK(ecode2)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14237 }
14238 arg2 = static_cast< int >(val2);
14239 ecode3 = SWIG_AsVal_int(obj2, &val3);
14240 if (!SWIG_IsOK(ecode3)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14242 }
14243 arg3 = static_cast< int >(val3);
14244 if (obj3) {
14245 ecode4 = SWIG_AsVal_int(obj3, &val4);
14246 if (!SWIG_IsOK(ecode4)) {
14247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14248 }
14249 arg4 = static_cast< int >(val4);
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 {
14254 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14255 result = (wxImage *) &_result_ref;
14256 }
14257 wxPyEndAllowThreads(__tstate);
14258 if (PyErr_Occurred()) SWIG_fail;
14259 }
14260 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14261 return resultobj;
14262 fail:
14263 return NULL;
14264 }
14265
14266
14267 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14268 PyObject *resultobj = 0;
14269 wxImage *arg1 = (wxImage *) 0 ;
14270 wxSize *arg2 = 0 ;
14271 wxPoint *arg3 = 0 ;
14272 int arg4 = (int) -1 ;
14273 int arg5 = (int) -1 ;
14274 int arg6 = (int) -1 ;
14275 wxImage *result = 0 ;
14276 void *argp1 = 0 ;
14277 int res1 = 0 ;
14278 wxSize temp2 ;
14279 wxPoint temp3 ;
14280 int val4 ;
14281 int ecode4 = 0 ;
14282 int val5 ;
14283 int ecode5 = 0 ;
14284 int val6 ;
14285 int ecode6 = 0 ;
14286 PyObject * obj0 = 0 ;
14287 PyObject * obj1 = 0 ;
14288 PyObject * obj2 = 0 ;
14289 PyObject * obj3 = 0 ;
14290 PyObject * obj4 = 0 ;
14291 PyObject * obj5 = 0 ;
14292 char * kwnames[] = {
14293 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14294 };
14295
14296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14298 if (!SWIG_IsOK(res1)) {
14299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14300 }
14301 arg1 = reinterpret_cast< wxImage * >(argp1);
14302 {
14303 arg2 = &temp2;
14304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14305 }
14306 {
14307 arg3 = &temp3;
14308 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14309 }
14310 if (obj3) {
14311 ecode4 = SWIG_AsVal_int(obj3, &val4);
14312 if (!SWIG_IsOK(ecode4)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14314 }
14315 arg4 = static_cast< int >(val4);
14316 }
14317 if (obj4) {
14318 ecode5 = SWIG_AsVal_int(obj4, &val5);
14319 if (!SWIG_IsOK(ecode5)) {
14320 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14321 }
14322 arg5 = static_cast< int >(val5);
14323 }
14324 if (obj5) {
14325 ecode6 = SWIG_AsVal_int(obj5, &val6);
14326 if (!SWIG_IsOK(ecode6)) {
14327 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14328 }
14329 arg6 = static_cast< int >(val6);
14330 }
14331 {
14332 PyThreadState* __tstate = wxPyBeginAllowThreads();
14333 {
14334 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14335 result = (wxImage *) &_result_ref;
14336 }
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj = 0;
14349 wxImage *arg1 = (wxImage *) 0 ;
14350 int arg2 ;
14351 int arg3 ;
14352 byte arg4 ;
14353 byte arg5 ;
14354 byte arg6 ;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 int val2 ;
14358 int ecode2 = 0 ;
14359 int val3 ;
14360 int ecode3 = 0 ;
14361 unsigned char val4 ;
14362 int ecode4 = 0 ;
14363 unsigned char val5 ;
14364 int ecode5 = 0 ;
14365 unsigned char val6 ;
14366 int ecode6 = 0 ;
14367 PyObject * obj0 = 0 ;
14368 PyObject * obj1 = 0 ;
14369 PyObject * obj2 = 0 ;
14370 PyObject * obj3 = 0 ;
14371 PyObject * obj4 = 0 ;
14372 PyObject * obj5 = 0 ;
14373 char * kwnames[] = {
14374 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14375 };
14376
14377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14379 if (!SWIG_IsOK(res1)) {
14380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14381 }
14382 arg1 = reinterpret_cast< wxImage * >(argp1);
14383 ecode2 = SWIG_AsVal_int(obj1, &val2);
14384 if (!SWIG_IsOK(ecode2)) {
14385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14386 }
14387 arg2 = static_cast< int >(val2);
14388 ecode3 = SWIG_AsVal_int(obj2, &val3);
14389 if (!SWIG_IsOK(ecode3)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14391 }
14392 arg3 = static_cast< int >(val3);
14393 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14394 if (!SWIG_IsOK(ecode4)) {
14395 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14396 }
14397 arg4 = static_cast< byte >(val4);
14398 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14399 if (!SWIG_IsOK(ecode5)) {
14400 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14401 }
14402 arg5 = static_cast< byte >(val5);
14403 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14404 if (!SWIG_IsOK(ecode6)) {
14405 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14406 }
14407 arg6 = static_cast< byte >(val6);
14408 {
14409 PyThreadState* __tstate = wxPyBeginAllowThreads();
14410 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 resultobj = SWIG_Py_Void();
14415 return resultobj;
14416 fail:
14417 return NULL;
14418 }
14419
14420
14421 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14422 PyObject *resultobj = 0;
14423 wxImage *arg1 = (wxImage *) 0 ;
14424 wxRect *arg2 = 0 ;
14425 byte arg3 ;
14426 byte arg4 ;
14427 byte arg5 ;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 wxRect temp2 ;
14431 unsigned char val3 ;
14432 int ecode3 = 0 ;
14433 unsigned char val4 ;
14434 int ecode4 = 0 ;
14435 unsigned char val5 ;
14436 int ecode5 = 0 ;
14437 PyObject * obj0 = 0 ;
14438 PyObject * obj1 = 0 ;
14439 PyObject * obj2 = 0 ;
14440 PyObject * obj3 = 0 ;
14441 PyObject * obj4 = 0 ;
14442 char * kwnames[] = {
14443 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14444 };
14445
14446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14448 if (!SWIG_IsOK(res1)) {
14449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14450 }
14451 arg1 = reinterpret_cast< wxImage * >(argp1);
14452 {
14453 arg2 = &temp2;
14454 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14455 }
14456 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14457 if (!SWIG_IsOK(ecode3)) {
14458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14459 }
14460 arg3 = static_cast< byte >(val3);
14461 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14462 if (!SWIG_IsOK(ecode4)) {
14463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14464 }
14465 arg4 = static_cast< byte >(val4);
14466 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14467 if (!SWIG_IsOK(ecode5)) {
14468 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14469 }
14470 arg5 = static_cast< byte >(val5);
14471 {
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14474 wxPyEndAllowThreads(__tstate);
14475 if (PyErr_Occurred()) SWIG_fail;
14476 }
14477 resultobj = SWIG_Py_Void();
14478 return resultobj;
14479 fail:
14480 return NULL;
14481 }
14482
14483
14484 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14485 PyObject *resultobj = 0;
14486 wxImage *arg1 = (wxImage *) 0 ;
14487 int arg2 ;
14488 int arg3 ;
14489 byte result;
14490 void *argp1 = 0 ;
14491 int res1 = 0 ;
14492 int val2 ;
14493 int ecode2 = 0 ;
14494 int val3 ;
14495 int ecode3 = 0 ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 PyObject * obj2 = 0 ;
14499 char * kwnames[] = {
14500 (char *) "self",(char *) "x",(char *) "y", NULL
14501 };
14502
14503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14505 if (!SWIG_IsOK(res1)) {
14506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14507 }
14508 arg1 = reinterpret_cast< wxImage * >(argp1);
14509 ecode2 = SWIG_AsVal_int(obj1, &val2);
14510 if (!SWIG_IsOK(ecode2)) {
14511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14512 }
14513 arg2 = static_cast< int >(val2);
14514 ecode3 = SWIG_AsVal_int(obj2, &val3);
14515 if (!SWIG_IsOK(ecode3)) {
14516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14517 }
14518 arg3 = static_cast< int >(val3);
14519 {
14520 PyThreadState* __tstate = wxPyBeginAllowThreads();
14521 result = (byte)(arg1)->GetRed(arg2,arg3);
14522 wxPyEndAllowThreads(__tstate);
14523 if (PyErr_Occurred()) SWIG_fail;
14524 }
14525 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14526 return resultobj;
14527 fail:
14528 return NULL;
14529 }
14530
14531
14532 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14533 PyObject *resultobj = 0;
14534 wxImage *arg1 = (wxImage *) 0 ;
14535 int arg2 ;
14536 int arg3 ;
14537 byte result;
14538 void *argp1 = 0 ;
14539 int res1 = 0 ;
14540 int val2 ;
14541 int ecode2 = 0 ;
14542 int val3 ;
14543 int ecode3 = 0 ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 char * kwnames[] = {
14548 (char *) "self",(char *) "x",(char *) "y", NULL
14549 };
14550
14551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14553 if (!SWIG_IsOK(res1)) {
14554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14555 }
14556 arg1 = reinterpret_cast< wxImage * >(argp1);
14557 ecode2 = SWIG_AsVal_int(obj1, &val2);
14558 if (!SWIG_IsOK(ecode2)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14560 }
14561 arg2 = static_cast< int >(val2);
14562 ecode3 = SWIG_AsVal_int(obj2, &val3);
14563 if (!SWIG_IsOK(ecode3)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14565 }
14566 arg3 = static_cast< int >(val3);
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (byte)(arg1)->GetGreen(arg2,arg3);
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14574 return resultobj;
14575 fail:
14576 return NULL;
14577 }
14578
14579
14580 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14581 PyObject *resultobj = 0;
14582 wxImage *arg1 = (wxImage *) 0 ;
14583 int arg2 ;
14584 int arg3 ;
14585 byte result;
14586 void *argp1 = 0 ;
14587 int res1 = 0 ;
14588 int val2 ;
14589 int ecode2 = 0 ;
14590 int val3 ;
14591 int ecode3 = 0 ;
14592 PyObject * obj0 = 0 ;
14593 PyObject * obj1 = 0 ;
14594 PyObject * obj2 = 0 ;
14595 char * kwnames[] = {
14596 (char *) "self",(char *) "x",(char *) "y", NULL
14597 };
14598
14599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14601 if (!SWIG_IsOK(res1)) {
14602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14603 }
14604 arg1 = reinterpret_cast< wxImage * >(argp1);
14605 ecode2 = SWIG_AsVal_int(obj1, &val2);
14606 if (!SWIG_IsOK(ecode2)) {
14607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14608 }
14609 arg2 = static_cast< int >(val2);
14610 ecode3 = SWIG_AsVal_int(obj2, &val3);
14611 if (!SWIG_IsOK(ecode3)) {
14612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14613 }
14614 arg3 = static_cast< int >(val3);
14615 {
14616 PyThreadState* __tstate = wxPyBeginAllowThreads();
14617 result = (byte)(arg1)->GetBlue(arg2,arg3);
14618 wxPyEndAllowThreads(__tstate);
14619 if (PyErr_Occurred()) SWIG_fail;
14620 }
14621 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14629 PyObject *resultobj = 0;
14630 wxImage *arg1 = (wxImage *) 0 ;
14631 int arg2 ;
14632 int arg3 ;
14633 byte arg4 ;
14634 void *argp1 = 0 ;
14635 int res1 = 0 ;
14636 int val2 ;
14637 int ecode2 = 0 ;
14638 int val3 ;
14639 int ecode3 = 0 ;
14640 unsigned char val4 ;
14641 int ecode4 = 0 ;
14642 PyObject * obj0 = 0 ;
14643 PyObject * obj1 = 0 ;
14644 PyObject * obj2 = 0 ;
14645 PyObject * obj3 = 0 ;
14646 char * kwnames[] = {
14647 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14648 };
14649
14650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14652 if (!SWIG_IsOK(res1)) {
14653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14654 }
14655 arg1 = reinterpret_cast< wxImage * >(argp1);
14656 ecode2 = SWIG_AsVal_int(obj1, &val2);
14657 if (!SWIG_IsOK(ecode2)) {
14658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14659 }
14660 arg2 = static_cast< int >(val2);
14661 ecode3 = SWIG_AsVal_int(obj2, &val3);
14662 if (!SWIG_IsOK(ecode3)) {
14663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14664 }
14665 arg3 = static_cast< int >(val3);
14666 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14667 if (!SWIG_IsOK(ecode4)) {
14668 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14669 }
14670 arg4 = static_cast< byte >(val4);
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 (arg1)->SetAlpha(arg2,arg3,arg4);
14674 wxPyEndAllowThreads(__tstate);
14675 if (PyErr_Occurred()) SWIG_fail;
14676 }
14677 resultobj = SWIG_Py_Void();
14678 return resultobj;
14679 fail:
14680 return NULL;
14681 }
14682
14683
14684 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14685 PyObject *resultobj = 0;
14686 wxImage *arg1 = (wxImage *) 0 ;
14687 int arg2 ;
14688 int arg3 ;
14689 byte result;
14690 void *argp1 = 0 ;
14691 int res1 = 0 ;
14692 int val2 ;
14693 int ecode2 = 0 ;
14694 int val3 ;
14695 int ecode3 = 0 ;
14696 PyObject * obj0 = 0 ;
14697 PyObject * obj1 = 0 ;
14698 PyObject * obj2 = 0 ;
14699 char * kwnames[] = {
14700 (char *) "self",(char *) "x",(char *) "y", NULL
14701 };
14702
14703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14707 }
14708 arg1 = reinterpret_cast< wxImage * >(argp1);
14709 ecode2 = SWIG_AsVal_int(obj1, &val2);
14710 if (!SWIG_IsOK(ecode2)) {
14711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14712 }
14713 arg2 = static_cast< int >(val2);
14714 ecode3 = SWIG_AsVal_int(obj2, &val3);
14715 if (!SWIG_IsOK(ecode3)) {
14716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14717 }
14718 arg3 = static_cast< int >(val3);
14719 {
14720 PyThreadState* __tstate = wxPyBeginAllowThreads();
14721 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14722 wxPyEndAllowThreads(__tstate);
14723 if (PyErr_Occurred()) SWIG_fail;
14724 }
14725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14726 return resultobj;
14727 fail:
14728 return NULL;
14729 }
14730
14731
14732 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14733 PyObject *resultobj = 0;
14734 wxImage *arg1 = (wxImage *) 0 ;
14735 bool result;
14736 void *argp1 = 0 ;
14737 int res1 = 0 ;
14738 PyObject *swig_obj[1] ;
14739
14740 if (!args) SWIG_fail;
14741 swig_obj[0] = args;
14742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14743 if (!SWIG_IsOK(res1)) {
14744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14745 }
14746 arg1 = reinterpret_cast< wxImage * >(argp1);
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (bool)(arg1)->HasAlpha();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 {
14754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14755 }
14756 return resultobj;
14757 fail:
14758 return NULL;
14759 }
14760
14761
14762 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14763 PyObject *resultobj = 0;
14764 wxImage *arg1 = (wxImage *) 0 ;
14765 void *argp1 = 0 ;
14766 int res1 = 0 ;
14767 PyObject *swig_obj[1] ;
14768
14769 if (!args) SWIG_fail;
14770 swig_obj[0] = args;
14771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14772 if (!SWIG_IsOK(res1)) {
14773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14774 }
14775 arg1 = reinterpret_cast< wxImage * >(argp1);
14776 {
14777 PyThreadState* __tstate = wxPyBeginAllowThreads();
14778 (arg1)->InitAlpha();
14779 wxPyEndAllowThreads(__tstate);
14780 if (PyErr_Occurred()) SWIG_fail;
14781 }
14782 resultobj = SWIG_Py_Void();
14783 return resultobj;
14784 fail:
14785 return NULL;
14786 }
14787
14788
14789 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14790 PyObject *resultobj = 0;
14791 wxImage *arg1 = (wxImage *) 0 ;
14792 int arg2 ;
14793 int arg3 ;
14794 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14795 bool result;
14796 void *argp1 = 0 ;
14797 int res1 = 0 ;
14798 int val2 ;
14799 int ecode2 = 0 ;
14800 int val3 ;
14801 int ecode3 = 0 ;
14802 unsigned char val4 ;
14803 int ecode4 = 0 ;
14804 PyObject * obj0 = 0 ;
14805 PyObject * obj1 = 0 ;
14806 PyObject * obj2 = 0 ;
14807 PyObject * obj3 = 0 ;
14808 char * kwnames[] = {
14809 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14810 };
14811
14812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14814 if (!SWIG_IsOK(res1)) {
14815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14816 }
14817 arg1 = reinterpret_cast< wxImage * >(argp1);
14818 ecode2 = SWIG_AsVal_int(obj1, &val2);
14819 if (!SWIG_IsOK(ecode2)) {
14820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14821 }
14822 arg2 = static_cast< int >(val2);
14823 ecode3 = SWIG_AsVal_int(obj2, &val3);
14824 if (!SWIG_IsOK(ecode3)) {
14825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14826 }
14827 arg3 = static_cast< int >(val3);
14828 if (obj3) {
14829 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14830 if (!SWIG_IsOK(ecode4)) {
14831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14832 }
14833 arg4 = static_cast< byte >(val4);
14834 }
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14843 }
14844 return resultobj;
14845 fail:
14846 return NULL;
14847 }
14848
14849
14850 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14851 PyObject *resultobj = 0;
14852 wxImage *arg1 = (wxImage *) 0 ;
14853 byte *arg2 = (byte *) 0 ;
14854 byte *arg3 = (byte *) 0 ;
14855 byte *arg4 = (byte *) 0 ;
14856 byte arg5 = (byte) 0 ;
14857 byte arg6 = (byte) 0 ;
14858 byte arg7 = (byte) 0 ;
14859 bool result;
14860 void *argp1 = 0 ;
14861 int res1 = 0 ;
14862 byte temp2 ;
14863 int res2 = SWIG_TMPOBJ ;
14864 byte temp3 ;
14865 int res3 = SWIG_TMPOBJ ;
14866 byte temp4 ;
14867 int res4 = SWIG_TMPOBJ ;
14868 unsigned char val5 ;
14869 int ecode5 = 0 ;
14870 unsigned char val6 ;
14871 int ecode6 = 0 ;
14872 unsigned char val7 ;
14873 int ecode7 = 0 ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 PyObject * obj2 = 0 ;
14877 PyObject * obj3 = 0 ;
14878 char * kwnames[] = {
14879 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14880 };
14881
14882 arg2 = &temp2;
14883 arg3 = &temp3;
14884 arg4 = &temp4;
14885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14887 if (!SWIG_IsOK(res1)) {
14888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14889 }
14890 arg1 = reinterpret_cast< wxImage * >(argp1);
14891 if (obj1) {
14892 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14893 if (!SWIG_IsOK(ecode5)) {
14894 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14895 }
14896 arg5 = static_cast< byte >(val5);
14897 }
14898 if (obj2) {
14899 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14900 if (!SWIG_IsOK(ecode6)) {
14901 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14902 }
14903 arg6 = static_cast< byte >(val6);
14904 }
14905 if (obj3) {
14906 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14907 if (!SWIG_IsOK(ecode7)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14909 }
14910 arg7 = static_cast< byte >(val7);
14911 }
14912 {
14913 PyThreadState* __tstate = wxPyBeginAllowThreads();
14914 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14915 wxPyEndAllowThreads(__tstate);
14916 if (PyErr_Occurred()) SWIG_fail;
14917 }
14918 {
14919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14920 }
14921 if (SWIG_IsTmpObj(res2)) {
14922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14923 } else {
14924 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14925 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14926 }
14927 if (SWIG_IsTmpObj(res3)) {
14928 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14929 } else {
14930 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14931 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14932 }
14933 if (SWIG_IsTmpObj(res4)) {
14934 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14935 } else {
14936 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14937 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14938 }
14939 return resultobj;
14940 fail:
14941 return NULL;
14942 }
14943
14944
14945 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14946 PyObject *resultobj = 0;
14947 wxImage *arg1 = (wxImage *) 0 ;
14948 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14949 bool result;
14950 void *argp1 = 0 ;
14951 int res1 = 0 ;
14952 unsigned char val2 ;
14953 int ecode2 = 0 ;
14954 PyObject * obj0 = 0 ;
14955 PyObject * obj1 = 0 ;
14956 char * kwnames[] = {
14957 (char *) "self",(char *) "threshold", NULL
14958 };
14959
14960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14962 if (!SWIG_IsOK(res1)) {
14963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14964 }
14965 arg1 = reinterpret_cast< wxImage * >(argp1);
14966 if (obj1) {
14967 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14968 if (!SWIG_IsOK(ecode2)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14970 }
14971 arg2 = static_cast< byte >(val2);
14972 }
14973 {
14974 PyThreadState* __tstate = wxPyBeginAllowThreads();
14975 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14976 wxPyEndAllowThreads(__tstate);
14977 if (PyErr_Occurred()) SWIG_fail;
14978 }
14979 {
14980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14981 }
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxImage *arg1 = (wxImage *) 0 ;
14991 byte arg2 ;
14992 byte arg3 ;
14993 byte arg4 ;
14994 bool result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 unsigned char val2 ;
14998 int ecode2 = 0 ;
14999 unsigned char val3 ;
15000 int ecode3 = 0 ;
15001 unsigned char val4 ;
15002 int ecode4 = 0 ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 PyObject * obj2 = 0 ;
15006 PyObject * obj3 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImage * >(argp1);
15017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15018 if (!SWIG_IsOK(ecode2)) {
15019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15020 }
15021 arg2 = static_cast< byte >(val2);
15022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15023 if (!SWIG_IsOK(ecode3)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15025 }
15026 arg3 = static_cast< byte >(val3);
15027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15028 if (!SWIG_IsOK(ecode4)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15030 }
15031 arg4 = static_cast< byte >(val4);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 {
15039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15040 }
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj = 0;
15049 wxImage *arg1 = (wxImage *) 0 ;
15050 wxImage *arg2 = 0 ;
15051 byte arg3 ;
15052 byte arg4 ;
15053 byte arg5 ;
15054 bool result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 void *argp2 = 0 ;
15058 int res2 = 0 ;
15059 unsigned char val3 ;
15060 int ecode3 = 0 ;
15061 unsigned char val4 ;
15062 int ecode4 = 0 ;
15063 unsigned char val5 ;
15064 int ecode5 = 0 ;
15065 PyObject * obj0 = 0 ;
15066 PyObject * obj1 = 0 ;
15067 PyObject * obj2 = 0 ;
15068 PyObject * obj3 = 0 ;
15069 PyObject * obj4 = 0 ;
15070 char * kwnames[] = {
15071 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15072 };
15073
15074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15076 if (!SWIG_IsOK(res1)) {
15077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15078 }
15079 arg1 = reinterpret_cast< wxImage * >(argp1);
15080 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15081 if (!SWIG_IsOK(res2)) {
15082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15083 }
15084 if (!argp2) {
15085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15086 }
15087 arg2 = reinterpret_cast< wxImage * >(argp2);
15088 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15089 if (!SWIG_IsOK(ecode3)) {
15090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15091 }
15092 arg3 = static_cast< byte >(val3);
15093 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15094 if (!SWIG_IsOK(ecode4)) {
15095 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15096 }
15097 arg4 = static_cast< byte >(val4);
15098 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15099 if (!SWIG_IsOK(ecode5)) {
15100 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15101 }
15102 arg5 = static_cast< byte >(val5);
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 {
15110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15111 }
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj = 0;
15120 wxString *arg1 = 0 ;
15121 bool result;
15122 bool temp1 = false ;
15123 PyObject * obj0 = 0 ;
15124 char * kwnames[] = {
15125 (char *) "filename", NULL
15126 };
15127
15128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15129 {
15130 arg1 = wxString_in_helper(obj0);
15131 if (arg1 == NULL) SWIG_fail;
15132 temp1 = true;
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 {
15141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15142 }
15143 {
15144 if (temp1)
15145 delete arg1;
15146 }
15147 return resultobj;
15148 fail:
15149 {
15150 if (temp1)
15151 delete arg1;
15152 }
15153 return NULL;
15154 }
15155
15156
15157 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15158 PyObject *resultobj = 0;
15159 wxString *arg1 = 0 ;
15160 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15161 int result;
15162 bool temp1 = false ;
15163 long val2 ;
15164 int ecode2 = 0 ;
15165 PyObject * obj0 = 0 ;
15166 PyObject * obj1 = 0 ;
15167 char * kwnames[] = {
15168 (char *) "filename",(char *) "type", NULL
15169 };
15170
15171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15172 {
15173 arg1 = wxString_in_helper(obj0);
15174 if (arg1 == NULL) SWIG_fail;
15175 temp1 = true;
15176 }
15177 if (obj1) {
15178 ecode2 = SWIG_AsVal_long(obj1, &val2);
15179 if (!SWIG_IsOK(ecode2)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15181 }
15182 arg2 = static_cast< long >(val2);
15183 }
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 resultobj = SWIG_From_int(static_cast< int >(result));
15191 {
15192 if (temp1)
15193 delete arg1;
15194 }
15195 return resultobj;
15196 fail:
15197 {
15198 if (temp1)
15199 delete arg1;
15200 }
15201 return NULL;
15202 }
15203
15204
15205 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj = 0;
15207 wxImage *arg1 = (wxImage *) 0 ;
15208 wxString *arg2 = 0 ;
15209 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15210 int arg4 = (int) -1 ;
15211 bool result;
15212 void *argp1 = 0 ;
15213 int res1 = 0 ;
15214 bool temp2 = false ;
15215 long val3 ;
15216 int ecode3 = 0 ;
15217 int val4 ;
15218 int ecode4 = 0 ;
15219 PyObject * obj0 = 0 ;
15220 PyObject * obj1 = 0 ;
15221 PyObject * obj2 = 0 ;
15222 PyObject * obj3 = 0 ;
15223 char * kwnames[] = {
15224 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15225 };
15226
15227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15229 if (!SWIG_IsOK(res1)) {
15230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15231 }
15232 arg1 = reinterpret_cast< wxImage * >(argp1);
15233 {
15234 arg2 = wxString_in_helper(obj1);
15235 if (arg2 == NULL) SWIG_fail;
15236 temp2 = true;
15237 }
15238 if (obj2) {
15239 ecode3 = SWIG_AsVal_long(obj2, &val3);
15240 if (!SWIG_IsOK(ecode3)) {
15241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15242 }
15243 arg3 = static_cast< long >(val3);
15244 }
15245 if (obj3) {
15246 ecode4 = SWIG_AsVal_int(obj3, &val4);
15247 if (!SWIG_IsOK(ecode4)) {
15248 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15249 }
15250 arg4 = static_cast< int >(val4);
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 {
15259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15260 }
15261 {
15262 if (temp2)
15263 delete arg2;
15264 }
15265 return resultobj;
15266 fail:
15267 {
15268 if (temp2)
15269 delete arg2;
15270 }
15271 return NULL;
15272 }
15273
15274
15275 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15276 PyObject *resultobj = 0;
15277 wxImage *arg1 = (wxImage *) 0 ;
15278 wxString *arg2 = 0 ;
15279 wxString *arg3 = 0 ;
15280 int arg4 = (int) -1 ;
15281 bool result;
15282 void *argp1 = 0 ;
15283 int res1 = 0 ;
15284 bool temp2 = false ;
15285 bool temp3 = false ;
15286 int val4 ;
15287 int ecode4 = 0 ;
15288 PyObject * obj0 = 0 ;
15289 PyObject * obj1 = 0 ;
15290 PyObject * obj2 = 0 ;
15291 PyObject * obj3 = 0 ;
15292 char * kwnames[] = {
15293 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15294 };
15295
15296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15300 }
15301 arg1 = reinterpret_cast< wxImage * >(argp1);
15302 {
15303 arg2 = wxString_in_helper(obj1);
15304 if (arg2 == NULL) SWIG_fail;
15305 temp2 = true;
15306 }
15307 {
15308 arg3 = wxString_in_helper(obj2);
15309 if (arg3 == NULL) SWIG_fail;
15310 temp3 = true;
15311 }
15312 if (obj3) {
15313 ecode4 = SWIG_AsVal_int(obj3, &val4);
15314 if (!SWIG_IsOK(ecode4)) {
15315 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15316 }
15317 arg4 = static_cast< int >(val4);
15318 }
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15322 wxPyEndAllowThreads(__tstate);
15323 if (PyErr_Occurred()) SWIG_fail;
15324 }
15325 {
15326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15327 }
15328 {
15329 if (temp2)
15330 delete arg2;
15331 }
15332 {
15333 if (temp3)
15334 delete arg3;
15335 }
15336 return resultobj;
15337 fail:
15338 {
15339 if (temp2)
15340 delete arg2;
15341 }
15342 {
15343 if (temp3)
15344 delete arg3;
15345 }
15346 return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15351 PyObject *resultobj = 0;
15352 wxImage *arg1 = (wxImage *) 0 ;
15353 wxString *arg2 = 0 ;
15354 int arg3 ;
15355 bool result;
15356 void *argp1 = 0 ;
15357 int res1 = 0 ;
15358 bool temp2 = false ;
15359 int val3 ;
15360 int ecode3 = 0 ;
15361 PyObject * obj0 = 0 ;
15362 PyObject * obj1 = 0 ;
15363 PyObject * obj2 = 0 ;
15364 char * kwnames[] = {
15365 (char *) "self",(char *) "name",(char *) "type", NULL
15366 };
15367
15368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15370 if (!SWIG_IsOK(res1)) {
15371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15372 }
15373 arg1 = reinterpret_cast< wxImage * >(argp1);
15374 {
15375 arg2 = wxString_in_helper(obj1);
15376 if (arg2 == NULL) SWIG_fail;
15377 temp2 = true;
15378 }
15379 ecode3 = SWIG_AsVal_int(obj2, &val3);
15380 if (!SWIG_IsOK(ecode3)) {
15381 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15382 }
15383 arg3 = static_cast< int >(val3);
15384 {
15385 PyThreadState* __tstate = wxPyBeginAllowThreads();
15386 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15387 wxPyEndAllowThreads(__tstate);
15388 if (PyErr_Occurred()) SWIG_fail;
15389 }
15390 {
15391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15392 }
15393 {
15394 if (temp2)
15395 delete arg2;
15396 }
15397 return resultobj;
15398 fail:
15399 {
15400 if (temp2)
15401 delete arg2;
15402 }
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxImage *arg1 = (wxImage *) 0 ;
15410 wxString *arg2 = 0 ;
15411 wxString *arg3 = 0 ;
15412 bool result;
15413 void *argp1 = 0 ;
15414 int res1 = 0 ;
15415 bool temp2 = false ;
15416 bool temp3 = false ;
15417 PyObject * obj0 = 0 ;
15418 PyObject * obj1 = 0 ;
15419 PyObject * obj2 = 0 ;
15420 char * kwnames[] = {
15421 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15422 };
15423
15424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15426 if (!SWIG_IsOK(res1)) {
15427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15428 }
15429 arg1 = reinterpret_cast< wxImage * >(argp1);
15430 {
15431 arg2 = wxString_in_helper(obj1);
15432 if (arg2 == NULL) SWIG_fail;
15433 temp2 = true;
15434 }
15435 {
15436 arg3 = wxString_in_helper(obj2);
15437 if (arg3 == NULL) SWIG_fail;
15438 temp3 = true;
15439 }
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15443 wxPyEndAllowThreads(__tstate);
15444 if (PyErr_Occurred()) SWIG_fail;
15445 }
15446 {
15447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15448 }
15449 {
15450 if (temp2)
15451 delete arg2;
15452 }
15453 {
15454 if (temp3)
15455 delete arg3;
15456 }
15457 return resultobj;
15458 fail:
15459 {
15460 if (temp2)
15461 delete arg2;
15462 }
15463 {
15464 if (temp3)
15465 delete arg3;
15466 }
15467 return NULL;
15468 }
15469
15470
15471 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj = 0;
15473 wxInputStream *arg1 = 0 ;
15474 bool result;
15475 wxPyInputStream *temp1 ;
15476 bool created1 ;
15477 PyObject * obj0 = 0 ;
15478 char * kwnames[] = {
15479 (char *) "stream", NULL
15480 };
15481
15482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15483 {
15484 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15485 arg1 = temp1->m_wxis;
15486 created1 = false;
15487 } else {
15488 PyErr_Clear(); // clear the failure of the wxPyConvert above
15489 arg1 = wxPyCBInputStream_create(obj0, false);
15490 if (arg1 == NULL) {
15491 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15492 SWIG_fail;
15493 }
15494 created1 = true;
15495 }
15496 }
15497 {
15498 PyThreadState* __tstate = wxPyBeginAllowThreads();
15499 result = (bool)wxImage::CanRead(*arg1);
15500 wxPyEndAllowThreads(__tstate);
15501 if (PyErr_Occurred()) SWIG_fail;
15502 }
15503 {
15504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15505 }
15506 {
15507 if (created1) delete arg1;
15508 }
15509 return resultobj;
15510 fail:
15511 {
15512 if (created1) delete arg1;
15513 }
15514 return NULL;
15515 }
15516
15517
15518 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15519 PyObject *resultobj = 0;
15520 wxImage *arg1 = (wxImage *) 0 ;
15521 wxInputStream *arg2 = 0 ;
15522 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15523 int arg4 = (int) -1 ;
15524 bool result;
15525 void *argp1 = 0 ;
15526 int res1 = 0 ;
15527 wxPyInputStream *temp2 ;
15528 bool created2 ;
15529 long val3 ;
15530 int ecode3 = 0 ;
15531 int val4 ;
15532 int ecode4 = 0 ;
15533 PyObject * obj0 = 0 ;
15534 PyObject * obj1 = 0 ;
15535 PyObject * obj2 = 0 ;
15536 PyObject * obj3 = 0 ;
15537 char * kwnames[] = {
15538 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15539 };
15540
15541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15543 if (!SWIG_IsOK(res1)) {
15544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15545 }
15546 arg1 = reinterpret_cast< wxImage * >(argp1);
15547 {
15548 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15549 arg2 = temp2->m_wxis;
15550 created2 = false;
15551 } else {
15552 PyErr_Clear(); // clear the failure of the wxPyConvert above
15553 arg2 = wxPyCBInputStream_create(obj1, false);
15554 if (arg2 == NULL) {
15555 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15556 SWIG_fail;
15557 }
15558 created2 = true;
15559 }
15560 }
15561 if (obj2) {
15562 ecode3 = SWIG_AsVal_long(obj2, &val3);
15563 if (!SWIG_IsOK(ecode3)) {
15564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15565 }
15566 arg3 = static_cast< long >(val3);
15567 }
15568 if (obj3) {
15569 ecode4 = SWIG_AsVal_int(obj3, &val4);
15570 if (!SWIG_IsOK(ecode4)) {
15571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15572 }
15573 arg4 = static_cast< int >(val4);
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 {
15582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15583 }
15584 {
15585 if (created2) delete arg2;
15586 }
15587 return resultobj;
15588 fail:
15589 {
15590 if (created2) delete arg2;
15591 }
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15597 PyObject *resultobj = 0;
15598 wxImage *arg1 = (wxImage *) 0 ;
15599 wxInputStream *arg2 = 0 ;
15600 wxString *arg3 = 0 ;
15601 int arg4 = (int) -1 ;
15602 bool result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 wxPyInputStream *temp2 ;
15606 bool created2 ;
15607 bool temp3 = false ;
15608 int val4 ;
15609 int ecode4 = 0 ;
15610 PyObject * obj0 = 0 ;
15611 PyObject * obj1 = 0 ;
15612 PyObject * obj2 = 0 ;
15613 PyObject * obj3 = 0 ;
15614 char * kwnames[] = {
15615 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15616 };
15617
15618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15620 if (!SWIG_IsOK(res1)) {
15621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15622 }
15623 arg1 = reinterpret_cast< wxImage * >(argp1);
15624 {
15625 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15626 arg2 = temp2->m_wxis;
15627 created2 = false;
15628 } else {
15629 PyErr_Clear(); // clear the failure of the wxPyConvert above
15630 arg2 = wxPyCBInputStream_create(obj1, false);
15631 if (arg2 == NULL) {
15632 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15633 SWIG_fail;
15634 }
15635 created2 = true;
15636 }
15637 }
15638 {
15639 arg3 = wxString_in_helper(obj2);
15640 if (arg3 == NULL) SWIG_fail;
15641 temp3 = true;
15642 }
15643 if (obj3) {
15644 ecode4 = SWIG_AsVal_int(obj3, &val4);
15645 if (!SWIG_IsOK(ecode4)) {
15646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15647 }
15648 arg4 = static_cast< int >(val4);
15649 }
15650 {
15651 PyThreadState* __tstate = wxPyBeginAllowThreads();
15652 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 {
15657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15658 }
15659 {
15660 if (created2) delete arg2;
15661 }
15662 {
15663 if (temp3)
15664 delete arg3;
15665 }
15666 return resultobj;
15667 fail:
15668 {
15669 if (created2) delete arg2;
15670 }
15671 {
15672 if (temp3)
15673 delete arg3;
15674 }
15675 return NULL;
15676 }
15677
15678
15679 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15680 PyObject *resultobj = 0;
15681 wxImage *arg1 = (wxImage *) 0 ;
15682 bool result;
15683 void *argp1 = 0 ;
15684 int res1 = 0 ;
15685 PyObject *swig_obj[1] ;
15686
15687 if (!args) SWIG_fail;
15688 swig_obj[0] = args;
15689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15690 if (!SWIG_IsOK(res1)) {
15691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15692 }
15693 arg1 = reinterpret_cast< wxImage * >(argp1);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 result = (bool)(arg1)->IsOk();
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 {
15701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15702 }
15703 return resultobj;
15704 fail:
15705 return NULL;
15706 }
15707
15708
15709 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15710 PyObject *resultobj = 0;
15711 wxImage *arg1 = (wxImage *) 0 ;
15712 int result;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 PyObject *swig_obj[1] ;
15716
15717 if (!args) SWIG_fail;
15718 swig_obj[0] = args;
15719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15720 if (!SWIG_IsOK(res1)) {
15721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15722 }
15723 arg1 = reinterpret_cast< wxImage * >(argp1);
15724 {
15725 PyThreadState* __tstate = wxPyBeginAllowThreads();
15726 result = (int)(arg1)->GetWidth();
15727 wxPyEndAllowThreads(__tstate);
15728 if (PyErr_Occurred()) SWIG_fail;
15729 }
15730 resultobj = SWIG_From_int(static_cast< int >(result));
15731 return resultobj;
15732 fail:
15733 return NULL;
15734 }
15735
15736
15737 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15738 PyObject *resultobj = 0;
15739 wxImage *arg1 = (wxImage *) 0 ;
15740 int result;
15741 void *argp1 = 0 ;
15742 int res1 = 0 ;
15743 PyObject *swig_obj[1] ;
15744
15745 if (!args) SWIG_fail;
15746 swig_obj[0] = args;
15747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15750 }
15751 arg1 = reinterpret_cast< wxImage * >(argp1);
15752 {
15753 PyThreadState* __tstate = wxPyBeginAllowThreads();
15754 result = (int)(arg1)->GetHeight();
15755 wxPyEndAllowThreads(__tstate);
15756 if (PyErr_Occurred()) SWIG_fail;
15757 }
15758 resultobj = SWIG_From_int(static_cast< int >(result));
15759 return resultobj;
15760 fail:
15761 return NULL;
15762 }
15763
15764
15765 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15766 PyObject *resultobj = 0;
15767 wxImage *arg1 = (wxImage *) 0 ;
15768 wxSize result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 PyObject *swig_obj[1] ;
15772
15773 if (!args) SWIG_fail;
15774 swig_obj[0] = args;
15775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15776 if (!SWIG_IsOK(res1)) {
15777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15778 }
15779 arg1 = reinterpret_cast< wxImage * >(argp1);
15780 {
15781 PyThreadState* __tstate = wxPyBeginAllowThreads();
15782 result = wxImage_GetSize(arg1);
15783 wxPyEndAllowThreads(__tstate);
15784 if (PyErr_Occurred()) SWIG_fail;
15785 }
15786 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15787 return resultobj;
15788 fail:
15789 return NULL;
15790 }
15791
15792
15793 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15794 PyObject *resultobj = 0;
15795 wxImage *arg1 = (wxImage *) 0 ;
15796 wxRect *arg2 = 0 ;
15797 SwigValueWrapper<wxImage > result;
15798 void *argp1 = 0 ;
15799 int res1 = 0 ;
15800 wxRect temp2 ;
15801 PyObject * obj0 = 0 ;
15802 PyObject * obj1 = 0 ;
15803 char * kwnames[] = {
15804 (char *) "self",(char *) "rect", NULL
15805 };
15806
15807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15809 if (!SWIG_IsOK(res1)) {
15810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15811 }
15812 arg1 = reinterpret_cast< wxImage * >(argp1);
15813 {
15814 arg2 = &temp2;
15815 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15816 }
15817 {
15818 PyThreadState* __tstate = wxPyBeginAllowThreads();
15819 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15824 return resultobj;
15825 fail:
15826 return NULL;
15827 }
15828
15829
15830 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15831 PyObject *resultobj = 0;
15832 wxImage *arg1 = (wxImage *) 0 ;
15833 wxSize *arg2 = 0 ;
15834 wxPoint *arg3 = 0 ;
15835 int arg4 = (int) -1 ;
15836 int arg5 = (int) -1 ;
15837 int arg6 = (int) -1 ;
15838 SwigValueWrapper<wxImage > result;
15839 void *argp1 = 0 ;
15840 int res1 = 0 ;
15841 wxSize temp2 ;
15842 wxPoint temp3 ;
15843 int val4 ;
15844 int ecode4 = 0 ;
15845 int val5 ;
15846 int ecode5 = 0 ;
15847 int val6 ;
15848 int ecode6 = 0 ;
15849 PyObject * obj0 = 0 ;
15850 PyObject * obj1 = 0 ;
15851 PyObject * obj2 = 0 ;
15852 PyObject * obj3 = 0 ;
15853 PyObject * obj4 = 0 ;
15854 PyObject * obj5 = 0 ;
15855 char * kwnames[] = {
15856 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15857 };
15858
15859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15861 if (!SWIG_IsOK(res1)) {
15862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15863 }
15864 arg1 = reinterpret_cast< wxImage * >(argp1);
15865 {
15866 arg2 = &temp2;
15867 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15868 }
15869 {
15870 arg3 = &temp3;
15871 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15872 }
15873 if (obj3) {
15874 ecode4 = SWIG_AsVal_int(obj3, &val4);
15875 if (!SWIG_IsOK(ecode4)) {
15876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15877 }
15878 arg4 = static_cast< int >(val4);
15879 }
15880 if (obj4) {
15881 ecode5 = SWIG_AsVal_int(obj4, &val5);
15882 if (!SWIG_IsOK(ecode5)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15884 }
15885 arg5 = static_cast< int >(val5);
15886 }
15887 if (obj5) {
15888 ecode6 = SWIG_AsVal_int(obj5, &val6);
15889 if (!SWIG_IsOK(ecode6)) {
15890 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15891 }
15892 arg6 = static_cast< int >(val6);
15893 }
15894 {
15895 PyThreadState* __tstate = wxPyBeginAllowThreads();
15896 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15897 wxPyEndAllowThreads(__tstate);
15898 if (PyErr_Occurred()) SWIG_fail;
15899 }
15900 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15901 return resultobj;
15902 fail:
15903 return NULL;
15904 }
15905
15906
15907 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15908 PyObject *resultobj = 0;
15909 wxImage *arg1 = (wxImage *) 0 ;
15910 SwigValueWrapper<wxImage > result;
15911 void *argp1 = 0 ;
15912 int res1 = 0 ;
15913 PyObject *swig_obj[1] ;
15914
15915 if (!args) SWIG_fail;
15916 swig_obj[0] = args;
15917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15918 if (!SWIG_IsOK(res1)) {
15919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15920 }
15921 arg1 = reinterpret_cast< wxImage * >(argp1);
15922 {
15923 PyThreadState* __tstate = wxPyBeginAllowThreads();
15924 result = (arg1)->Copy();
15925 wxPyEndAllowThreads(__tstate);
15926 if (PyErr_Occurred()) SWIG_fail;
15927 }
15928 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15929 return resultobj;
15930 fail:
15931 return NULL;
15932 }
15933
15934
15935 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15936 PyObject *resultobj = 0;
15937 wxImage *arg1 = (wxImage *) 0 ;
15938 wxImage *arg2 = 0 ;
15939 int arg3 ;
15940 int arg4 ;
15941 void *argp1 = 0 ;
15942 int res1 = 0 ;
15943 void *argp2 = 0 ;
15944 int res2 = 0 ;
15945 int val3 ;
15946 int ecode3 = 0 ;
15947 int val4 ;
15948 int ecode4 = 0 ;
15949 PyObject * obj0 = 0 ;
15950 PyObject * obj1 = 0 ;
15951 PyObject * obj2 = 0 ;
15952 PyObject * obj3 = 0 ;
15953 char * kwnames[] = {
15954 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15955 };
15956
15957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15959 if (!SWIG_IsOK(res1)) {
15960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15961 }
15962 arg1 = reinterpret_cast< wxImage * >(argp1);
15963 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15964 if (!SWIG_IsOK(res2)) {
15965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15966 }
15967 if (!argp2) {
15968 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15969 }
15970 arg2 = reinterpret_cast< wxImage * >(argp2);
15971 ecode3 = SWIG_AsVal_int(obj2, &val3);
15972 if (!SWIG_IsOK(ecode3)) {
15973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15974 }
15975 arg3 = static_cast< int >(val3);
15976 ecode4 = SWIG_AsVal_int(obj3, &val4);
15977 if (!SWIG_IsOK(ecode4)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15979 }
15980 arg4 = static_cast< int >(val4);
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15984 wxPyEndAllowThreads(__tstate);
15985 if (PyErr_Occurred()) SWIG_fail;
15986 }
15987 resultobj = SWIG_Py_Void();
15988 return resultobj;
15989 fail:
15990 return NULL;
15991 }
15992
15993
15994 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15995 PyObject *resultobj = 0;
15996 wxImage *arg1 = (wxImage *) 0 ;
15997 PyObject *result = 0 ;
15998 void *argp1 = 0 ;
15999 int res1 = 0 ;
16000 PyObject *swig_obj[1] ;
16001
16002 if (!args) SWIG_fail;
16003 swig_obj[0] = args;
16004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16005 if (!SWIG_IsOK(res1)) {
16006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16007 }
16008 arg1 = reinterpret_cast< wxImage * >(argp1);
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 result = (PyObject *)wxImage_GetData(arg1);
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 resultobj = result;
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj = 0;
16024 wxImage *arg1 = (wxImage *) 0 ;
16025 buffer arg2 ;
16026 int arg3 ;
16027 void *argp1 = 0 ;
16028 int res1 = 0 ;
16029 Py_ssize_t temp2 ;
16030 PyObject * obj0 = 0 ;
16031 PyObject * obj1 = 0 ;
16032 char * kwnames[] = {
16033 (char *) "self",(char *) "data", NULL
16034 };
16035
16036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16038 if (!SWIG_IsOK(res1)) {
16039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16040 }
16041 arg1 = reinterpret_cast< wxImage * >(argp1);
16042 {
16043 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16044 arg3 = (int)temp2;
16045 }
16046 {
16047 PyThreadState* __tstate = wxPyBeginAllowThreads();
16048 wxImage_SetData(arg1,arg2,arg3);
16049 wxPyEndAllowThreads(__tstate);
16050 if (PyErr_Occurred()) SWIG_fail;
16051 }
16052 resultobj = SWIG_Py_Void();
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16060 PyObject *resultobj = 0;
16061 wxImage *arg1 = (wxImage *) 0 ;
16062 PyObject *result = 0 ;
16063 void *argp1 = 0 ;
16064 int res1 = 0 ;
16065 PyObject *swig_obj[1] ;
16066
16067 if (!args) SWIG_fail;
16068 swig_obj[0] = args;
16069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16070 if (!SWIG_IsOK(res1)) {
16071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16072 }
16073 arg1 = reinterpret_cast< wxImage * >(argp1);
16074 {
16075 PyThreadState* __tstate = wxPyBeginAllowThreads();
16076 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 resultobj = result;
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16088 PyObject *resultobj = 0;
16089 wxImage *arg1 = (wxImage *) 0 ;
16090 buffer arg2 ;
16091 int arg3 ;
16092 void *argp1 = 0 ;
16093 int res1 = 0 ;
16094 Py_ssize_t temp2 ;
16095 PyObject * obj0 = 0 ;
16096 PyObject * obj1 = 0 ;
16097 char * kwnames[] = {
16098 (char *) "self",(char *) "data", NULL
16099 };
16100
16101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16103 if (!SWIG_IsOK(res1)) {
16104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16105 }
16106 arg1 = reinterpret_cast< wxImage * >(argp1);
16107 {
16108 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16109 arg3 = (int)temp2;
16110 }
16111 {
16112 PyThreadState* __tstate = wxPyBeginAllowThreads();
16113 wxImage_SetDataBuffer(arg1,arg2,arg3);
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 resultobj = SWIG_Py_Void();
16118 return resultobj;
16119 fail:
16120 return NULL;
16121 }
16122
16123
16124 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16125 PyObject *resultobj = 0;
16126 wxImage *arg1 = (wxImage *) 0 ;
16127 PyObject *result = 0 ;
16128 void *argp1 = 0 ;
16129 int res1 = 0 ;
16130 PyObject *swig_obj[1] ;
16131
16132 if (!args) SWIG_fail;
16133 swig_obj[0] = args;
16134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16135 if (!SWIG_IsOK(res1)) {
16136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16137 }
16138 arg1 = reinterpret_cast< wxImage * >(argp1);
16139 {
16140 PyThreadState* __tstate = wxPyBeginAllowThreads();
16141 result = (PyObject *)wxImage_GetAlphaData(arg1);
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 resultobj = result;
16146 return resultobj;
16147 fail:
16148 return NULL;
16149 }
16150
16151
16152 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16153 PyObject *resultobj = 0;
16154 wxImage *arg1 = (wxImage *) 0 ;
16155 buffer arg2 ;
16156 int arg3 ;
16157 void *argp1 = 0 ;
16158 int res1 = 0 ;
16159 Py_ssize_t temp2 ;
16160 PyObject * obj0 = 0 ;
16161 PyObject * obj1 = 0 ;
16162 char * kwnames[] = {
16163 (char *) "self",(char *) "alpha", NULL
16164 };
16165
16166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16170 }
16171 arg1 = reinterpret_cast< wxImage * >(argp1);
16172 {
16173 if (obj1 != Py_None) {
16174 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16175 arg3 = (int)temp2;
16176 }
16177 }
16178 {
16179 PyThreadState* __tstate = wxPyBeginAllowThreads();
16180 wxImage_SetAlphaData(arg1,arg2,arg3);
16181 wxPyEndAllowThreads(__tstate);
16182 if (PyErr_Occurred()) SWIG_fail;
16183 }
16184 resultobj = SWIG_Py_Void();
16185 return resultobj;
16186 fail:
16187 return NULL;
16188 }
16189
16190
16191 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16192 PyObject *resultobj = 0;
16193 wxImage *arg1 = (wxImage *) 0 ;
16194 PyObject *result = 0 ;
16195 void *argp1 = 0 ;
16196 int res1 = 0 ;
16197 PyObject *swig_obj[1] ;
16198
16199 if (!args) SWIG_fail;
16200 swig_obj[0] = args;
16201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16202 if (!SWIG_IsOK(res1)) {
16203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16204 }
16205 arg1 = reinterpret_cast< wxImage * >(argp1);
16206 {
16207 PyThreadState* __tstate = wxPyBeginAllowThreads();
16208 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16209 wxPyEndAllowThreads(__tstate);
16210 if (PyErr_Occurred()) SWIG_fail;
16211 }
16212 resultobj = result;
16213 return resultobj;
16214 fail:
16215 return NULL;
16216 }
16217
16218
16219 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16220 PyObject *resultobj = 0;
16221 wxImage *arg1 = (wxImage *) 0 ;
16222 buffer arg2 ;
16223 int arg3 ;
16224 void *argp1 = 0 ;
16225 int res1 = 0 ;
16226 Py_ssize_t temp2 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 char * kwnames[] = {
16230 (char *) "self",(char *) "alpha", NULL
16231 };
16232
16233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16235 if (!SWIG_IsOK(res1)) {
16236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16237 }
16238 arg1 = reinterpret_cast< wxImage * >(argp1);
16239 {
16240 if (obj1 != Py_None) {
16241 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16242 arg3 = (int)temp2;
16243 }
16244 }
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16248 wxPyEndAllowThreads(__tstate);
16249 if (PyErr_Occurred()) SWIG_fail;
16250 }
16251 resultobj = SWIG_Py_Void();
16252 return resultobj;
16253 fail:
16254 return NULL;
16255 }
16256
16257
16258 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16259 PyObject *resultobj = 0;
16260 wxImage *arg1 = (wxImage *) 0 ;
16261 byte arg2 ;
16262 byte arg3 ;
16263 byte arg4 ;
16264 void *argp1 = 0 ;
16265 int res1 = 0 ;
16266 unsigned char val2 ;
16267 int ecode2 = 0 ;
16268 unsigned char val3 ;
16269 int ecode3 = 0 ;
16270 unsigned char val4 ;
16271 int ecode4 = 0 ;
16272 PyObject * obj0 = 0 ;
16273 PyObject * obj1 = 0 ;
16274 PyObject * obj2 = 0 ;
16275 PyObject * obj3 = 0 ;
16276 char * kwnames[] = {
16277 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16278 };
16279
16280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16282 if (!SWIG_IsOK(res1)) {
16283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16284 }
16285 arg1 = reinterpret_cast< wxImage * >(argp1);
16286 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16287 if (!SWIG_IsOK(ecode2)) {
16288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16289 }
16290 arg2 = static_cast< byte >(val2);
16291 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16292 if (!SWIG_IsOK(ecode3)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16294 }
16295 arg3 = static_cast< byte >(val3);
16296 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16297 if (!SWIG_IsOK(ecode4)) {
16298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16299 }
16300 arg4 = static_cast< byte >(val4);
16301 {
16302 PyThreadState* __tstate = wxPyBeginAllowThreads();
16303 (arg1)->SetMaskColour(arg2,arg3,arg4);
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 resultobj = SWIG_Py_Void();
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16315 PyObject *resultobj = 0;
16316 wxImage *arg1 = (wxImage *) 0 ;
16317 byte *arg2 = (byte *) 0 ;
16318 byte *arg3 = (byte *) 0 ;
16319 byte *arg4 = (byte *) 0 ;
16320 void *argp1 = 0 ;
16321 int res1 = 0 ;
16322 byte temp2 ;
16323 int res2 = SWIG_TMPOBJ ;
16324 byte temp3 ;
16325 int res3 = SWIG_TMPOBJ ;
16326 byte temp4 ;
16327 int res4 = SWIG_TMPOBJ ;
16328 PyObject *swig_obj[1] ;
16329
16330 arg2 = &temp2;
16331 arg3 = &temp3;
16332 arg4 = &temp4;
16333 if (!args) SWIG_fail;
16334 swig_obj[0] = args;
16335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16336 if (!SWIG_IsOK(res1)) {
16337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16338 }
16339 arg1 = reinterpret_cast< wxImage * >(argp1);
16340 {
16341 PyThreadState* __tstate = wxPyBeginAllowThreads();
16342 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16343 wxPyEndAllowThreads(__tstate);
16344 if (PyErr_Occurred()) SWIG_fail;
16345 }
16346 resultobj = SWIG_Py_Void();
16347 if (SWIG_IsTmpObj(res2)) {
16348 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16349 } else {
16350 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16352 }
16353 if (SWIG_IsTmpObj(res3)) {
16354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16355 } else {
16356 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16358 }
16359 if (SWIG_IsTmpObj(res4)) {
16360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16361 } else {
16362 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16364 }
16365 return resultobj;
16366 fail:
16367 return NULL;
16368 }
16369
16370
16371 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16372 PyObject *resultobj = 0;
16373 wxImage *arg1 = (wxImage *) 0 ;
16374 byte result;
16375 void *argp1 = 0 ;
16376 int res1 = 0 ;
16377 PyObject *swig_obj[1] ;
16378
16379 if (!args) SWIG_fail;
16380 swig_obj[0] = args;
16381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16384 }
16385 arg1 = reinterpret_cast< wxImage * >(argp1);
16386 {
16387 PyThreadState* __tstate = wxPyBeginAllowThreads();
16388 result = (byte)(arg1)->GetMaskRed();
16389 wxPyEndAllowThreads(__tstate);
16390 if (PyErr_Occurred()) SWIG_fail;
16391 }
16392 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16393 return resultobj;
16394 fail:
16395 return NULL;
16396 }
16397
16398
16399 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16400 PyObject *resultobj = 0;
16401 wxImage *arg1 = (wxImage *) 0 ;
16402 byte result;
16403 void *argp1 = 0 ;
16404 int res1 = 0 ;
16405 PyObject *swig_obj[1] ;
16406
16407 if (!args) SWIG_fail;
16408 swig_obj[0] = args;
16409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16410 if (!SWIG_IsOK(res1)) {
16411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16412 }
16413 arg1 = reinterpret_cast< wxImage * >(argp1);
16414 {
16415 PyThreadState* __tstate = wxPyBeginAllowThreads();
16416 result = (byte)(arg1)->GetMaskGreen();
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16428 PyObject *resultobj = 0;
16429 wxImage *arg1 = (wxImage *) 0 ;
16430 byte result;
16431 void *argp1 = 0 ;
16432 int res1 = 0 ;
16433 PyObject *swig_obj[1] ;
16434
16435 if (!args) SWIG_fail;
16436 swig_obj[0] = args;
16437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16438 if (!SWIG_IsOK(res1)) {
16439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16440 }
16441 arg1 = reinterpret_cast< wxImage * >(argp1);
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 result = (byte)(arg1)->GetMaskBlue();
16445 wxPyEndAllowThreads(__tstate);
16446 if (PyErr_Occurred()) SWIG_fail;
16447 }
16448 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16449 return resultobj;
16450 fail:
16451 return NULL;
16452 }
16453
16454
16455 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16456 PyObject *resultobj = 0;
16457 wxImage *arg1 = (wxImage *) 0 ;
16458 bool arg2 = (bool) true ;
16459 void *argp1 = 0 ;
16460 int res1 = 0 ;
16461 bool val2 ;
16462 int ecode2 = 0 ;
16463 PyObject * obj0 = 0 ;
16464 PyObject * obj1 = 0 ;
16465 char * kwnames[] = {
16466 (char *) "self",(char *) "mask", NULL
16467 };
16468
16469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16471 if (!SWIG_IsOK(res1)) {
16472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16473 }
16474 arg1 = reinterpret_cast< wxImage * >(argp1);
16475 if (obj1) {
16476 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16477 if (!SWIG_IsOK(ecode2)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16479 }
16480 arg2 = static_cast< bool >(val2);
16481 }
16482 {
16483 PyThreadState* __tstate = wxPyBeginAllowThreads();
16484 (arg1)->SetMask(arg2);
16485 wxPyEndAllowThreads(__tstate);
16486 if (PyErr_Occurred()) SWIG_fail;
16487 }
16488 resultobj = SWIG_Py_Void();
16489 return resultobj;
16490 fail:
16491 return NULL;
16492 }
16493
16494
16495 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16496 PyObject *resultobj = 0;
16497 wxImage *arg1 = (wxImage *) 0 ;
16498 bool result;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 PyObject *swig_obj[1] ;
16502
16503 if (!args) SWIG_fail;
16504 swig_obj[0] = args;
16505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16506 if (!SWIG_IsOK(res1)) {
16507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16508 }
16509 arg1 = reinterpret_cast< wxImage * >(argp1);
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)(arg1)->HasMask();
16513 wxPyEndAllowThreads(__tstate);
16514 if (PyErr_Occurred()) SWIG_fail;
16515 }
16516 {
16517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16518 }
16519 return resultobj;
16520 fail:
16521 return NULL;
16522 }
16523
16524
16525 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16526 PyObject *resultobj = 0;
16527 wxImage *arg1 = (wxImage *) 0 ;
16528 double arg2 ;
16529 wxPoint *arg3 = 0 ;
16530 bool arg4 = (bool) true ;
16531 wxPoint *arg5 = (wxPoint *) NULL ;
16532 SwigValueWrapper<wxImage > result;
16533 void *argp1 = 0 ;
16534 int res1 = 0 ;
16535 double val2 ;
16536 int ecode2 = 0 ;
16537 wxPoint temp3 ;
16538 bool val4 ;
16539 int ecode4 = 0 ;
16540 void *argp5 = 0 ;
16541 int res5 = 0 ;
16542 PyObject * obj0 = 0 ;
16543 PyObject * obj1 = 0 ;
16544 PyObject * obj2 = 0 ;
16545 PyObject * obj3 = 0 ;
16546 PyObject * obj4 = 0 ;
16547 char * kwnames[] = {
16548 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16549 };
16550
16551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16553 if (!SWIG_IsOK(res1)) {
16554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16555 }
16556 arg1 = reinterpret_cast< wxImage * >(argp1);
16557 ecode2 = SWIG_AsVal_double(obj1, &val2);
16558 if (!SWIG_IsOK(ecode2)) {
16559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16560 }
16561 arg2 = static_cast< double >(val2);
16562 {
16563 arg3 = &temp3;
16564 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16565 }
16566 if (obj3) {
16567 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16568 if (!SWIG_IsOK(ecode4)) {
16569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16570 }
16571 arg4 = static_cast< bool >(val4);
16572 }
16573 if (obj4) {
16574 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16575 if (!SWIG_IsOK(res5)) {
16576 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16577 }
16578 arg5 = reinterpret_cast< wxPoint * >(argp5);
16579 }
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16583 wxPyEndAllowThreads(__tstate);
16584 if (PyErr_Occurred()) SWIG_fail;
16585 }
16586 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16587 return resultobj;
16588 fail:
16589 return NULL;
16590 }
16591
16592
16593 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16594 PyObject *resultobj = 0;
16595 wxImage *arg1 = (wxImage *) 0 ;
16596 bool arg2 = (bool) true ;
16597 SwigValueWrapper<wxImage > result;
16598 void *argp1 = 0 ;
16599 int res1 = 0 ;
16600 bool val2 ;
16601 int ecode2 = 0 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 char * kwnames[] = {
16605 (char *) "self",(char *) "clockwise", NULL
16606 };
16607
16608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16610 if (!SWIG_IsOK(res1)) {
16611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16612 }
16613 arg1 = reinterpret_cast< wxImage * >(argp1);
16614 if (obj1) {
16615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16616 if (!SWIG_IsOK(ecode2)) {
16617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16618 }
16619 arg2 = static_cast< bool >(val2);
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 result = (arg1)->Rotate90(arg2);
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj = 0;
16636 wxImage *arg1 = (wxImage *) 0 ;
16637 bool arg2 = (bool) true ;
16638 SwigValueWrapper<wxImage > result;
16639 void *argp1 = 0 ;
16640 int res1 = 0 ;
16641 bool val2 ;
16642 int ecode2 = 0 ;
16643 PyObject * obj0 = 0 ;
16644 PyObject * obj1 = 0 ;
16645 char * kwnames[] = {
16646 (char *) "self",(char *) "horizontally", NULL
16647 };
16648
16649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16651 if (!SWIG_IsOK(res1)) {
16652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16653 }
16654 arg1 = reinterpret_cast< wxImage * >(argp1);
16655 if (obj1) {
16656 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16657 if (!SWIG_IsOK(ecode2)) {
16658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16659 }
16660 arg2 = static_cast< bool >(val2);
16661 }
16662 {
16663 PyThreadState* __tstate = wxPyBeginAllowThreads();
16664 result = (arg1)->Mirror(arg2);
16665 wxPyEndAllowThreads(__tstate);
16666 if (PyErr_Occurred()) SWIG_fail;
16667 }
16668 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16669 return resultobj;
16670 fail:
16671 return NULL;
16672 }
16673
16674
16675 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16676 PyObject *resultobj = 0;
16677 wxImage *arg1 = (wxImage *) 0 ;
16678 byte arg2 ;
16679 byte arg3 ;
16680 byte arg4 ;
16681 byte arg5 ;
16682 byte arg6 ;
16683 byte arg7 ;
16684 void *argp1 = 0 ;
16685 int res1 = 0 ;
16686 unsigned char val2 ;
16687 int ecode2 = 0 ;
16688 unsigned char val3 ;
16689 int ecode3 = 0 ;
16690 unsigned char val4 ;
16691 int ecode4 = 0 ;
16692 unsigned char val5 ;
16693 int ecode5 = 0 ;
16694 unsigned char val6 ;
16695 int ecode6 = 0 ;
16696 unsigned char val7 ;
16697 int ecode7 = 0 ;
16698 PyObject * obj0 = 0 ;
16699 PyObject * obj1 = 0 ;
16700 PyObject * obj2 = 0 ;
16701 PyObject * obj3 = 0 ;
16702 PyObject * obj4 = 0 ;
16703 PyObject * obj5 = 0 ;
16704 PyObject * obj6 = 0 ;
16705 char * kwnames[] = {
16706 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16707 };
16708
16709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16711 if (!SWIG_IsOK(res1)) {
16712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16713 }
16714 arg1 = reinterpret_cast< wxImage * >(argp1);
16715 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16716 if (!SWIG_IsOK(ecode2)) {
16717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16718 }
16719 arg2 = static_cast< byte >(val2);
16720 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16721 if (!SWIG_IsOK(ecode3)) {
16722 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16723 }
16724 arg3 = static_cast< byte >(val3);
16725 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16726 if (!SWIG_IsOK(ecode4)) {
16727 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16728 }
16729 arg4 = static_cast< byte >(val4);
16730 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16731 if (!SWIG_IsOK(ecode5)) {
16732 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16733 }
16734 arg5 = static_cast< byte >(val5);
16735 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16736 if (!SWIG_IsOK(ecode6)) {
16737 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16738 }
16739 arg6 = static_cast< byte >(val6);
16740 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16741 if (!SWIG_IsOK(ecode7)) {
16742 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16743 }
16744 arg7 = static_cast< byte >(val7);
16745 {
16746 PyThreadState* __tstate = wxPyBeginAllowThreads();
16747 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16748 wxPyEndAllowThreads(__tstate);
16749 if (PyErr_Occurred()) SWIG_fail;
16750 }
16751 resultobj = SWIG_Py_Void();
16752 return resultobj;
16753 fail:
16754 return NULL;
16755 }
16756
16757
16758 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16759 PyObject *resultobj = 0;
16760 wxImage *arg1 = (wxImage *) 0 ;
16761 double arg2 = (double) 0.299 ;
16762 double arg3 = (double) 0.587 ;
16763 double arg4 = (double) 0.114 ;
16764 SwigValueWrapper<wxImage > result;
16765 void *argp1 = 0 ;
16766 int res1 = 0 ;
16767 double val2 ;
16768 int ecode2 = 0 ;
16769 double val3 ;
16770 int ecode3 = 0 ;
16771 double val4 ;
16772 int ecode4 = 0 ;
16773 PyObject * obj0 = 0 ;
16774 PyObject * obj1 = 0 ;
16775 PyObject * obj2 = 0 ;
16776 PyObject * obj3 = 0 ;
16777 char * kwnames[] = {
16778 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16779 };
16780
16781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16783 if (!SWIG_IsOK(res1)) {
16784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16785 }
16786 arg1 = reinterpret_cast< wxImage * >(argp1);
16787 if (obj1) {
16788 ecode2 = SWIG_AsVal_double(obj1, &val2);
16789 if (!SWIG_IsOK(ecode2)) {
16790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16791 }
16792 arg2 = static_cast< double >(val2);
16793 }
16794 if (obj2) {
16795 ecode3 = SWIG_AsVal_double(obj2, &val3);
16796 if (!SWIG_IsOK(ecode3)) {
16797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16798 }
16799 arg3 = static_cast< double >(val3);
16800 }
16801 if (obj3) {
16802 ecode4 = SWIG_AsVal_double(obj3, &val4);
16803 if (!SWIG_IsOK(ecode4)) {
16804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16805 }
16806 arg4 = static_cast< double >(val4);
16807 }
16808 {
16809 PyThreadState* __tstate = wxPyBeginAllowThreads();
16810 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16811 wxPyEndAllowThreads(__tstate);
16812 if (PyErr_Occurred()) SWIG_fail;
16813 }
16814 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16822 PyObject *resultobj = 0;
16823 wxImage *arg1 = (wxImage *) 0 ;
16824 byte arg2 ;
16825 byte arg3 ;
16826 byte arg4 ;
16827 SwigValueWrapper<wxImage > result;
16828 void *argp1 = 0 ;
16829 int res1 = 0 ;
16830 unsigned char val2 ;
16831 int ecode2 = 0 ;
16832 unsigned char val3 ;
16833 int ecode3 = 0 ;
16834 unsigned char val4 ;
16835 int ecode4 = 0 ;
16836 PyObject * obj0 = 0 ;
16837 PyObject * obj1 = 0 ;
16838 PyObject * obj2 = 0 ;
16839 PyObject * obj3 = 0 ;
16840 char * kwnames[] = {
16841 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16842 };
16843
16844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16846 if (!SWIG_IsOK(res1)) {
16847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16848 }
16849 arg1 = reinterpret_cast< wxImage * >(argp1);
16850 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16851 if (!SWIG_IsOK(ecode2)) {
16852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16853 }
16854 arg2 = static_cast< byte >(val2);
16855 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16856 if (!SWIG_IsOK(ecode3)) {
16857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16858 }
16859 arg3 = static_cast< byte >(val3);
16860 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16861 if (!SWIG_IsOK(ecode4)) {
16862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16863 }
16864 arg4 = static_cast< byte >(val4);
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj = 0;
16880 wxImage *arg1 = (wxImage *) 0 ;
16881 wxString *arg2 = 0 ;
16882 wxString *arg3 = 0 ;
16883 void *argp1 = 0 ;
16884 int res1 = 0 ;
16885 bool temp2 = false ;
16886 bool temp3 = false ;
16887 PyObject * obj0 = 0 ;
16888 PyObject * obj1 = 0 ;
16889 PyObject * obj2 = 0 ;
16890 char * kwnames[] = {
16891 (char *) "self",(char *) "name",(char *) "value", NULL
16892 };
16893
16894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16896 if (!SWIG_IsOK(res1)) {
16897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16898 }
16899 arg1 = reinterpret_cast< wxImage * >(argp1);
16900 {
16901 arg2 = wxString_in_helper(obj1);
16902 if (arg2 == NULL) SWIG_fail;
16903 temp2 = true;
16904 }
16905 {
16906 arg3 = wxString_in_helper(obj2);
16907 if (arg3 == NULL) SWIG_fail;
16908 temp3 = true;
16909 }
16910 {
16911 PyThreadState* __tstate = wxPyBeginAllowThreads();
16912 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 resultobj = SWIG_Py_Void();
16917 {
16918 if (temp2)
16919 delete arg2;
16920 }
16921 {
16922 if (temp3)
16923 delete arg3;
16924 }
16925 return resultobj;
16926 fail:
16927 {
16928 if (temp2)
16929 delete arg2;
16930 }
16931 {
16932 if (temp3)
16933 delete arg3;
16934 }
16935 return NULL;
16936 }
16937
16938
16939 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj = 0;
16941 wxImage *arg1 = (wxImage *) 0 ;
16942 wxString *arg2 = 0 ;
16943 int arg3 ;
16944 void *argp1 = 0 ;
16945 int res1 = 0 ;
16946 bool temp2 = false ;
16947 int val3 ;
16948 int ecode3 = 0 ;
16949 PyObject * obj0 = 0 ;
16950 PyObject * obj1 = 0 ;
16951 PyObject * obj2 = 0 ;
16952 char * kwnames[] = {
16953 (char *) "self",(char *) "name",(char *) "value", NULL
16954 };
16955
16956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16958 if (!SWIG_IsOK(res1)) {
16959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16960 }
16961 arg1 = reinterpret_cast< wxImage * >(argp1);
16962 {
16963 arg2 = wxString_in_helper(obj1);
16964 if (arg2 == NULL) SWIG_fail;
16965 temp2 = true;
16966 }
16967 ecode3 = SWIG_AsVal_int(obj2, &val3);
16968 if (!SWIG_IsOK(ecode3)) {
16969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16970 }
16971 arg3 = static_cast< int >(val3);
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 (arg1)->SetOption((wxString const &)*arg2,arg3);
16975 wxPyEndAllowThreads(__tstate);
16976 if (PyErr_Occurred()) SWIG_fail;
16977 }
16978 resultobj = SWIG_Py_Void();
16979 {
16980 if (temp2)
16981 delete arg2;
16982 }
16983 return resultobj;
16984 fail:
16985 {
16986 if (temp2)
16987 delete arg2;
16988 }
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16994 PyObject *resultobj = 0;
16995 wxImage *arg1 = (wxImage *) 0 ;
16996 wxString *arg2 = 0 ;
16997 wxString result;
16998 void *argp1 = 0 ;
16999 int res1 = 0 ;
17000 bool temp2 = false ;
17001 PyObject * obj0 = 0 ;
17002 PyObject * obj1 = 0 ;
17003 char * kwnames[] = {
17004 (char *) "self",(char *) "name", NULL
17005 };
17006
17007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17009 if (!SWIG_IsOK(res1)) {
17010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17011 }
17012 arg1 = reinterpret_cast< wxImage * >(argp1);
17013 {
17014 arg2 = wxString_in_helper(obj1);
17015 if (arg2 == NULL) SWIG_fail;
17016 temp2 = true;
17017 }
17018 {
17019 PyThreadState* __tstate = wxPyBeginAllowThreads();
17020 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17021 wxPyEndAllowThreads(__tstate);
17022 if (PyErr_Occurred()) SWIG_fail;
17023 }
17024 {
17025 #if wxUSE_UNICODE
17026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17027 #else
17028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17029 #endif
17030 }
17031 {
17032 if (temp2)
17033 delete arg2;
17034 }
17035 return resultobj;
17036 fail:
17037 {
17038 if (temp2)
17039 delete arg2;
17040 }
17041 return NULL;
17042 }
17043
17044
17045 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17046 PyObject *resultobj = 0;
17047 wxImage *arg1 = (wxImage *) 0 ;
17048 wxString *arg2 = 0 ;
17049 int result;
17050 void *argp1 = 0 ;
17051 int res1 = 0 ;
17052 bool temp2 = false ;
17053 PyObject * obj0 = 0 ;
17054 PyObject * obj1 = 0 ;
17055 char * kwnames[] = {
17056 (char *) "self",(char *) "name", NULL
17057 };
17058
17059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17061 if (!SWIG_IsOK(res1)) {
17062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17063 }
17064 arg1 = reinterpret_cast< wxImage * >(argp1);
17065 {
17066 arg2 = wxString_in_helper(obj1);
17067 if (arg2 == NULL) SWIG_fail;
17068 temp2 = true;
17069 }
17070 {
17071 PyThreadState* __tstate = wxPyBeginAllowThreads();
17072 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 resultobj = SWIG_From_int(static_cast< int >(result));
17077 {
17078 if (temp2)
17079 delete arg2;
17080 }
17081 return resultobj;
17082 fail:
17083 {
17084 if (temp2)
17085 delete arg2;
17086 }
17087 return NULL;
17088 }
17089
17090
17091 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17092 PyObject *resultobj = 0;
17093 wxImage *arg1 = (wxImage *) 0 ;
17094 wxString *arg2 = 0 ;
17095 bool result;
17096 void *argp1 = 0 ;
17097 int res1 = 0 ;
17098 bool temp2 = false ;
17099 PyObject * obj0 = 0 ;
17100 PyObject * obj1 = 0 ;
17101 char * kwnames[] = {
17102 (char *) "self",(char *) "name", NULL
17103 };
17104
17105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17107 if (!SWIG_IsOK(res1)) {
17108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17109 }
17110 arg1 = reinterpret_cast< wxImage * >(argp1);
17111 {
17112 arg2 = wxString_in_helper(obj1);
17113 if (arg2 == NULL) SWIG_fail;
17114 temp2 = true;
17115 }
17116 {
17117 PyThreadState* __tstate = wxPyBeginAllowThreads();
17118 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17119 wxPyEndAllowThreads(__tstate);
17120 if (PyErr_Occurred()) SWIG_fail;
17121 }
17122 {
17123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17124 }
17125 {
17126 if (temp2)
17127 delete arg2;
17128 }
17129 return resultobj;
17130 fail:
17131 {
17132 if (temp2)
17133 delete arg2;
17134 }
17135 return NULL;
17136 }
17137
17138
17139 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj = 0;
17141 wxImage *arg1 = (wxImage *) 0 ;
17142 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17143 unsigned long result;
17144 void *argp1 = 0 ;
17145 int res1 = 0 ;
17146 unsigned long val2 ;
17147 int ecode2 = 0 ;
17148 PyObject * obj0 = 0 ;
17149 PyObject * obj1 = 0 ;
17150 char * kwnames[] = {
17151 (char *) "self",(char *) "stopafter", NULL
17152 };
17153
17154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17156 if (!SWIG_IsOK(res1)) {
17157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17158 }
17159 arg1 = reinterpret_cast< wxImage * >(argp1);
17160 if (obj1) {
17161 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17162 if (!SWIG_IsOK(ecode2)) {
17163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17164 }
17165 arg2 = static_cast< unsigned long >(val2);
17166 }
17167 {
17168 PyThreadState* __tstate = wxPyBeginAllowThreads();
17169 result = (unsigned long)(arg1)->CountColours(arg2);
17170 wxPyEndAllowThreads(__tstate);
17171 if (PyErr_Occurred()) SWIG_fail;
17172 }
17173 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17174 return resultobj;
17175 fail:
17176 return NULL;
17177 }
17178
17179
17180 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17181 PyObject *resultobj = 0;
17182 wxImage *arg1 = (wxImage *) 0 ;
17183 wxImageHistogram *arg2 = 0 ;
17184 unsigned long result;
17185 void *argp1 = 0 ;
17186 int res1 = 0 ;
17187 void *argp2 = 0 ;
17188 int res2 = 0 ;
17189 PyObject * obj0 = 0 ;
17190 PyObject * obj1 = 0 ;
17191 char * kwnames[] = {
17192 (char *) "self",(char *) "h", NULL
17193 };
17194
17195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17197 if (!SWIG_IsOK(res1)) {
17198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17199 }
17200 arg1 = reinterpret_cast< wxImage * >(argp1);
17201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17202 if (!SWIG_IsOK(res2)) {
17203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17204 }
17205 if (!argp2) {
17206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17207 }
17208 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17212 wxPyEndAllowThreads(__tstate);
17213 if (PyErr_Occurred()) SWIG_fail;
17214 }
17215 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17216 return resultobj;
17217 fail:
17218 return NULL;
17219 }
17220
17221
17222 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17223 PyObject *resultobj = 0;
17224 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17225 void *argp1 = 0 ;
17226 int res1 = 0 ;
17227 PyObject * obj0 = 0 ;
17228 char * kwnames[] = {
17229 (char *) "handler", NULL
17230 };
17231
17232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17234 if (!SWIG_IsOK(res1)) {
17235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17236 }
17237 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17238 {
17239 PyThreadState* __tstate = wxPyBeginAllowThreads();
17240 wxImage::AddHandler(arg1);
17241 wxPyEndAllowThreads(__tstate);
17242 if (PyErr_Occurred()) SWIG_fail;
17243 }
17244 resultobj = SWIG_Py_Void();
17245 return resultobj;
17246 fail:
17247 return NULL;
17248 }
17249
17250
17251 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17252 PyObject *resultobj = 0;
17253 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17254 void *argp1 = 0 ;
17255 int res1 = 0 ;
17256 PyObject * obj0 = 0 ;
17257 char * kwnames[] = {
17258 (char *) "handler", NULL
17259 };
17260
17261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17263 if (!SWIG_IsOK(res1)) {
17264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17265 }
17266 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17267 {
17268 PyThreadState* __tstate = wxPyBeginAllowThreads();
17269 wxImage::InsertHandler(arg1);
17270 wxPyEndAllowThreads(__tstate);
17271 if (PyErr_Occurred()) SWIG_fail;
17272 }
17273 resultobj = SWIG_Py_Void();
17274 return resultobj;
17275 fail:
17276 return NULL;
17277 }
17278
17279
17280 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17281 PyObject *resultobj = 0;
17282 wxString *arg1 = 0 ;
17283 bool result;
17284 bool temp1 = false ;
17285 PyObject * obj0 = 0 ;
17286 char * kwnames[] = {
17287 (char *) "name", NULL
17288 };
17289
17290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17291 {
17292 arg1 = wxString_in_helper(obj0);
17293 if (arg1 == NULL) SWIG_fail;
17294 temp1 = true;
17295 }
17296 {
17297 PyThreadState* __tstate = wxPyBeginAllowThreads();
17298 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17299 wxPyEndAllowThreads(__tstate);
17300 if (PyErr_Occurred()) SWIG_fail;
17301 }
17302 {
17303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17304 }
17305 {
17306 if (temp1)
17307 delete arg1;
17308 }
17309 return resultobj;
17310 fail:
17311 {
17312 if (temp1)
17313 delete arg1;
17314 }
17315 return NULL;
17316 }
17317
17318
17319 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 PyObject *resultobj = 0;
17321 PyObject *result = 0 ;
17322
17323 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17324 {
17325 PyThreadState* __tstate = wxPyBeginAllowThreads();
17326 result = (PyObject *)wxImage_GetHandlers();
17327 wxPyEndAllowThreads(__tstate);
17328 if (PyErr_Occurred()) SWIG_fail;
17329 }
17330 resultobj = result;
17331 return resultobj;
17332 fail:
17333 return NULL;
17334 }
17335
17336
17337 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17338 PyObject *resultobj = 0;
17339 wxString result;
17340
17341 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = wxImage::GetImageExtWildcard();
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 {
17349 #if wxUSE_UNICODE
17350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17351 #else
17352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17353 #endif
17354 }
17355 return resultobj;
17356 fail:
17357 return NULL;
17358 }
17359
17360
17361 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17362 PyObject *resultobj = 0;
17363 wxImage *arg1 = (wxImage *) 0 ;
17364 int arg2 = (int) -1 ;
17365 wxBitmap result;
17366 void *argp1 = 0 ;
17367 int res1 = 0 ;
17368 int val2 ;
17369 int ecode2 = 0 ;
17370 PyObject * obj0 = 0 ;
17371 PyObject * obj1 = 0 ;
17372 char * kwnames[] = {
17373 (char *) "self",(char *) "depth", NULL
17374 };
17375
17376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17378 if (!SWIG_IsOK(res1)) {
17379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17380 }
17381 arg1 = reinterpret_cast< wxImage * >(argp1);
17382 if (obj1) {
17383 ecode2 = SWIG_AsVal_int(obj1, &val2);
17384 if (!SWIG_IsOK(ecode2)) {
17385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17386 }
17387 arg2 = static_cast< int >(val2);
17388 }
17389 {
17390 if (!wxPyCheckForApp()) SWIG_fail;
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 result = wxImage_ConvertToBitmap(arg1,arg2);
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj = 0;
17405 wxImage *arg1 = (wxImage *) 0 ;
17406 byte arg2 ;
17407 byte arg3 ;
17408 byte arg4 ;
17409 wxBitmap result;
17410 void *argp1 = 0 ;
17411 int res1 = 0 ;
17412 unsigned char val2 ;
17413 int ecode2 = 0 ;
17414 unsigned char val3 ;
17415 int ecode3 = 0 ;
17416 unsigned char val4 ;
17417 int ecode4 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 PyObject * obj2 = 0 ;
17421 PyObject * obj3 = 0 ;
17422 char * kwnames[] = {
17423 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17424 };
17425
17426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17430 }
17431 arg1 = reinterpret_cast< wxImage * >(argp1);
17432 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17433 if (!SWIG_IsOK(ecode2)) {
17434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17435 }
17436 arg2 = static_cast< byte >(val2);
17437 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17438 if (!SWIG_IsOK(ecode3)) {
17439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17440 }
17441 arg3 = static_cast< byte >(val3);
17442 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17443 if (!SWIG_IsOK(ecode4)) {
17444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17445 }
17446 arg4 = static_cast< byte >(val4);
17447 {
17448 if (!wxPyCheckForApp()) SWIG_fail;
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17455 return resultobj;
17456 fail:
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17462 PyObject *resultobj = 0;
17463 wxImage *arg1 = (wxImage *) 0 ;
17464 double arg2 ;
17465 void *argp1 = 0 ;
17466 int res1 = 0 ;
17467 double val2 ;
17468 int ecode2 = 0 ;
17469 PyObject * obj0 = 0 ;
17470 PyObject * obj1 = 0 ;
17471 char * kwnames[] = {
17472 (char *) "self",(char *) "angle", NULL
17473 };
17474
17475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17477 if (!SWIG_IsOK(res1)) {
17478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17479 }
17480 arg1 = reinterpret_cast< wxImage * >(argp1);
17481 ecode2 = SWIG_AsVal_double(obj1, &val2);
17482 if (!SWIG_IsOK(ecode2)) {
17483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17484 }
17485 arg2 = static_cast< double >(val2);
17486 {
17487 PyThreadState* __tstate = wxPyBeginAllowThreads();
17488 (arg1)->RotateHue(arg2);
17489 wxPyEndAllowThreads(__tstate);
17490 if (PyErr_Occurred()) SWIG_fail;
17491 }
17492 resultobj = SWIG_Py_Void();
17493 return resultobj;
17494 fail:
17495 return NULL;
17496 }
17497
17498
17499 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17500 PyObject *resultobj = 0;
17501 wxImage_RGBValue arg1 ;
17502 wxImage_HSVValue result;
17503 void *argp1 ;
17504 int res1 = 0 ;
17505 PyObject * obj0 = 0 ;
17506 char * kwnames[] = {
17507 (char *) "rgb", NULL
17508 };
17509
17510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17511 {
17512 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17513 if (!SWIG_IsOK(res1)) {
17514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17515 }
17516 if (!argp1) {
17517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17518 } else {
17519 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17520 arg1 = *temp;
17521 if (SWIG_IsNewObj(res1)) delete temp;
17522 }
17523 }
17524 {
17525 PyThreadState* __tstate = wxPyBeginAllowThreads();
17526 result = wxImage::RGBtoHSV(arg1);
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj = 0;
17539 wxImage_HSVValue arg1 ;
17540 wxImage_RGBValue result;
17541 void *argp1 ;
17542 int res1 = 0 ;
17543 PyObject * obj0 = 0 ;
17544 char * kwnames[] = {
17545 (char *) "hsv", NULL
17546 };
17547
17548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17549 {
17550 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17551 if (!SWIG_IsOK(res1)) {
17552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17553 }
17554 if (!argp1) {
17555 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17556 } else {
17557 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17558 arg1 = *temp;
17559 if (SWIG_IsNewObj(res1)) delete temp;
17560 }
17561 }
17562 {
17563 PyThreadState* __tstate = wxPyBeginAllowThreads();
17564 result = wxImage::HSVtoRGB(arg1);
17565 wxPyEndAllowThreads(__tstate);
17566 if (PyErr_Occurred()) SWIG_fail;
17567 }
17568 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17569 return resultobj;
17570 fail:
17571 return NULL;
17572 }
17573
17574
17575 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17576 PyObject *obj;
17577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17578 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17579 return SWIG_Py_Void();
17580 }
17581
17582 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17583 return SWIG_Python_InitShadowInstance(args);
17584 }
17585
17586 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17587 PyObject *resultobj = 0;
17588 int arg1 ;
17589 int arg2 ;
17590 buffer arg3 ;
17591 int arg4 ;
17592 buffer arg5 = (buffer) NULL ;
17593 int arg6 = (int) 0 ;
17594 wxImage *result = 0 ;
17595 int val1 ;
17596 int ecode1 = 0 ;
17597 int val2 ;
17598 int ecode2 = 0 ;
17599 Py_ssize_t temp3 ;
17600 Py_ssize_t temp5 ;
17601 PyObject * obj0 = 0 ;
17602 PyObject * obj1 = 0 ;
17603 PyObject * obj2 = 0 ;
17604 PyObject * obj3 = 0 ;
17605 char * kwnames[] = {
17606 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17607 };
17608
17609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17610 ecode1 = SWIG_AsVal_int(obj0, &val1);
17611 if (!SWIG_IsOK(ecode1)) {
17612 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17613 }
17614 arg1 = static_cast< int >(val1);
17615 ecode2 = SWIG_AsVal_int(obj1, &val2);
17616 if (!SWIG_IsOK(ecode2)) {
17617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17618 }
17619 arg2 = static_cast< int >(val2);
17620 {
17621 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17622 arg4 = (int)temp3;
17623 }
17624 if (obj3) {
17625 {
17626 if (obj3 != Py_None) {
17627 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17628 arg6 = (int)temp5;
17629 }
17630 }
17631 }
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17635 wxPyEndAllowThreads(__tstate);
17636 if (PyErr_Occurred()) SWIG_fail;
17637 }
17638 {
17639 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17640 }
17641 return resultobj;
17642 fail:
17643 return NULL;
17644 }
17645
17646
17647 SWIGINTERN int NullImage_set(PyObject *) {
17648 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17649 return 1;
17650 }
17651
17652
17653 SWIGINTERN PyObject *NullImage_get(void) {
17654 PyObject *pyobj = 0;
17655
17656 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17657 return pyobj;
17658 }
17659
17660
17661 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17662 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17663 return 1;
17664 }
17665
17666
17667 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17668 PyObject *pyobj = 0;
17669
17670 {
17671 #if wxUSE_UNICODE
17672 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17673 #else
17674 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17675 #endif
17676 }
17677 return pyobj;
17678 }
17679
17680
17681 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17682 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17683 return 1;
17684 }
17685
17686
17687 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17688 PyObject *pyobj = 0;
17689
17690 {
17691 #if wxUSE_UNICODE
17692 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17693 #else
17694 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17695 #endif
17696 }
17697 return pyobj;
17698 }
17699
17700
17701 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17702 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17703 return 1;
17704 }
17705
17706
17707 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17708 PyObject *pyobj = 0;
17709
17710 {
17711 #if wxUSE_UNICODE
17712 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17713 #else
17714 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17715 #endif
17716 }
17717 return pyobj;
17718 }
17719
17720
17721 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17722 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17723 return 1;
17724 }
17725
17726
17727 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17728 PyObject *pyobj = 0;
17729
17730 {
17731 #if wxUSE_UNICODE
17732 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17733 #else
17734 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17735 #endif
17736 }
17737 return pyobj;
17738 }
17739
17740
17741 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17742 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17743 return 1;
17744 }
17745
17746
17747 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17748 PyObject *pyobj = 0;
17749
17750 {
17751 #if wxUSE_UNICODE
17752 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17753 #else
17754 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17755 #endif
17756 }
17757 return pyobj;
17758 }
17759
17760
17761 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17762 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17763 return 1;
17764 }
17765
17766
17767 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17768 PyObject *pyobj = 0;
17769
17770 {
17771 #if wxUSE_UNICODE
17772 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17773 #else
17774 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17775 #endif
17776 }
17777 return pyobj;
17778 }
17779
17780
17781 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17782 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17783 return 1;
17784 }
17785
17786
17787 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17788 PyObject *pyobj = 0;
17789
17790 {
17791 #if wxUSE_UNICODE
17792 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17793 #else
17794 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17795 #endif
17796 }
17797 return pyobj;
17798 }
17799
17800
17801 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17802 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17803 return 1;
17804 }
17805
17806
17807 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17808 PyObject *pyobj = 0;
17809
17810 {
17811 #if wxUSE_UNICODE
17812 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17813 #else
17814 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17815 #endif
17816 }
17817 return pyobj;
17818 }
17819
17820
17821 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17822 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17823 return 1;
17824 }
17825
17826
17827 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17828 PyObject *pyobj = 0;
17829
17830 {
17831 #if wxUSE_UNICODE
17832 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17833 #else
17834 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17835 #endif
17836 }
17837 return pyobj;
17838 }
17839
17840
17841 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17842 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17843 return 1;
17844 }
17845
17846
17847 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17848 PyObject *pyobj = 0;
17849
17850 {
17851 #if wxUSE_UNICODE
17852 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17853 #else
17854 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17855 #endif
17856 }
17857 return pyobj;
17858 }
17859
17860
17861 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17862 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17863 return 1;
17864 }
17865
17866
17867 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17868 PyObject *pyobj = 0;
17869
17870 {
17871 #if wxUSE_UNICODE
17872 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17873 #else
17874 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17875 #endif
17876 }
17877 return pyobj;
17878 }
17879
17880
17881 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17882 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17883 return 1;
17884 }
17885
17886
17887 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17888 PyObject *pyobj = 0;
17889
17890 {
17891 #if wxUSE_UNICODE
17892 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17893 #else
17894 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17895 #endif
17896 }
17897 return pyobj;
17898 }
17899
17900
17901 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17902 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17903 return 1;
17904 }
17905
17906
17907 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17908 PyObject *pyobj = 0;
17909
17910 {
17911 #if wxUSE_UNICODE
17912 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17913 #else
17914 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17915 #endif
17916 }
17917 return pyobj;
17918 }
17919
17920
17921 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17922 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17923 return 1;
17924 }
17925
17926
17927 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17928 PyObject *pyobj = 0;
17929
17930 {
17931 #if wxUSE_UNICODE
17932 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17933 #else
17934 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17935 #endif
17936 }
17937 return pyobj;
17938 }
17939
17940
17941 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17942 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17943 return 1;
17944 }
17945
17946
17947 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17948 PyObject *pyobj = 0;
17949
17950 {
17951 #if wxUSE_UNICODE
17952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17953 #else
17954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17955 #endif
17956 }
17957 return pyobj;
17958 }
17959
17960
17961 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17962 PyObject *resultobj = 0;
17963 wxBMPHandler *result = 0 ;
17964
17965 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17966 {
17967 PyThreadState* __tstate = wxPyBeginAllowThreads();
17968 result = (wxBMPHandler *)new wxBMPHandler();
17969 wxPyEndAllowThreads(__tstate);
17970 if (PyErr_Occurred()) SWIG_fail;
17971 }
17972 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17973 return resultobj;
17974 fail:
17975 return NULL;
17976 }
17977
17978
17979 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17980 PyObject *obj;
17981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17982 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17983 return SWIG_Py_Void();
17984 }
17985
17986 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17987 return SWIG_Python_InitShadowInstance(args);
17988 }
17989
17990 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17991 PyObject *resultobj = 0;
17992 wxICOHandler *result = 0 ;
17993
17994 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17995 {
17996 PyThreadState* __tstate = wxPyBeginAllowThreads();
17997 result = (wxICOHandler *)new wxICOHandler();
17998 wxPyEndAllowThreads(__tstate);
17999 if (PyErr_Occurred()) SWIG_fail;
18000 }
18001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18002 return resultobj;
18003 fail:
18004 return NULL;
18005 }
18006
18007
18008 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18009 PyObject *obj;
18010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18011 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18012 return SWIG_Py_Void();
18013 }
18014
18015 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18016 return SWIG_Python_InitShadowInstance(args);
18017 }
18018
18019 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18020 PyObject *resultobj = 0;
18021 wxCURHandler *result = 0 ;
18022
18023 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18024 {
18025 PyThreadState* __tstate = wxPyBeginAllowThreads();
18026 result = (wxCURHandler *)new wxCURHandler();
18027 wxPyEndAllowThreads(__tstate);
18028 if (PyErr_Occurred()) SWIG_fail;
18029 }
18030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18038 PyObject *obj;
18039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18040 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18041 return SWIG_Py_Void();
18042 }
18043
18044 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18045 return SWIG_Python_InitShadowInstance(args);
18046 }
18047
18048 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18049 PyObject *resultobj = 0;
18050 wxANIHandler *result = 0 ;
18051
18052 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18053 {
18054 PyThreadState* __tstate = wxPyBeginAllowThreads();
18055 result = (wxANIHandler *)new wxANIHandler();
18056 wxPyEndAllowThreads(__tstate);
18057 if (PyErr_Occurred()) SWIG_fail;
18058 }
18059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18067 PyObject *obj;
18068 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18069 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18070 return SWIG_Py_Void();
18071 }
18072
18073 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18074 return SWIG_Python_InitShadowInstance(args);
18075 }
18076
18077 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 PyObject *resultobj = 0;
18079 wxPNGHandler *result = 0 ;
18080
18081 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (wxPNGHandler *)new wxPNGHandler();
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18096 PyObject *obj;
18097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18098 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18099 return SWIG_Py_Void();
18100 }
18101
18102 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18103 return SWIG_Python_InitShadowInstance(args);
18104 }
18105
18106 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18107 PyObject *resultobj = 0;
18108 wxGIFHandler *result = 0 ;
18109
18110 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18111 {
18112 PyThreadState* __tstate = wxPyBeginAllowThreads();
18113 result = (wxGIFHandler *)new wxGIFHandler();
18114 wxPyEndAllowThreads(__tstate);
18115 if (PyErr_Occurred()) SWIG_fail;
18116 }
18117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18118 return resultobj;
18119 fail:
18120 return NULL;
18121 }
18122
18123
18124 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18125 PyObject *obj;
18126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18127 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18128 return SWIG_Py_Void();
18129 }
18130
18131 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18132 return SWIG_Python_InitShadowInstance(args);
18133 }
18134
18135 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18136 PyObject *resultobj = 0;
18137 wxPCXHandler *result = 0 ;
18138
18139 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18140 {
18141 PyThreadState* __tstate = wxPyBeginAllowThreads();
18142 result = (wxPCXHandler *)new wxPCXHandler();
18143 wxPyEndAllowThreads(__tstate);
18144 if (PyErr_Occurred()) SWIG_fail;
18145 }
18146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18154 PyObject *obj;
18155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18156 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18157 return SWIG_Py_Void();
18158 }
18159
18160 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18161 return SWIG_Python_InitShadowInstance(args);
18162 }
18163
18164 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18165 PyObject *resultobj = 0;
18166 wxJPEGHandler *result = 0 ;
18167
18168 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 result = (wxJPEGHandler *)new wxJPEGHandler();
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *obj;
18184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18185 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18186 return SWIG_Py_Void();
18187 }
18188
18189 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18190 return SWIG_Python_InitShadowInstance(args);
18191 }
18192
18193 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18194 PyObject *resultobj = 0;
18195 wxPNMHandler *result = 0 ;
18196
18197 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (wxPNMHandler *)new wxPNMHandler();
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18212 PyObject *obj;
18213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18214 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18215 return SWIG_Py_Void();
18216 }
18217
18218 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18219 return SWIG_Python_InitShadowInstance(args);
18220 }
18221
18222 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18223 PyObject *resultobj = 0;
18224 wxXPMHandler *result = 0 ;
18225
18226 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18227 {
18228 PyThreadState* __tstate = wxPyBeginAllowThreads();
18229 result = (wxXPMHandler *)new wxXPMHandler();
18230 wxPyEndAllowThreads(__tstate);
18231 if (PyErr_Occurred()) SWIG_fail;
18232 }
18233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18234 return resultobj;
18235 fail:
18236 return NULL;
18237 }
18238
18239
18240 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18241 PyObject *obj;
18242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18243 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18244 return SWIG_Py_Void();
18245 }
18246
18247 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18248 return SWIG_Python_InitShadowInstance(args);
18249 }
18250
18251 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18252 PyObject *resultobj = 0;
18253 wxTIFFHandler *result = 0 ;
18254
18255 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18256 {
18257 PyThreadState* __tstate = wxPyBeginAllowThreads();
18258 result = (wxTIFFHandler *)new wxTIFFHandler();
18259 wxPyEndAllowThreads(__tstate);
18260 if (PyErr_Occurred()) SWIG_fail;
18261 }
18262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18263 return resultobj;
18264 fail:
18265 return NULL;
18266 }
18267
18268
18269 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18270 PyObject *obj;
18271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18272 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18273 return SWIG_Py_Void();
18274 }
18275
18276 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18277 return SWIG_Python_InitShadowInstance(args);
18278 }
18279
18280 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18281 PyObject *resultobj = 0;
18282 wxImage *arg1 = 0 ;
18283 wxImage *arg2 = 0 ;
18284 int arg3 = (int) 236 ;
18285 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18286 bool result;
18287 void *argp1 = 0 ;
18288 int res1 = 0 ;
18289 void *argp2 = 0 ;
18290 int res2 = 0 ;
18291 int val3 ;
18292 int ecode3 = 0 ;
18293 int val4 ;
18294 int ecode4 = 0 ;
18295 PyObject * obj0 = 0 ;
18296 PyObject * obj1 = 0 ;
18297 PyObject * obj2 = 0 ;
18298 PyObject * obj3 = 0 ;
18299 char * kwnames[] = {
18300 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18301 };
18302
18303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18304 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18305 if (!SWIG_IsOK(res1)) {
18306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18307 }
18308 if (!argp1) {
18309 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18310 }
18311 arg1 = reinterpret_cast< wxImage * >(argp1);
18312 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18313 if (!SWIG_IsOK(res2)) {
18314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18315 }
18316 if (!argp2) {
18317 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18318 }
18319 arg2 = reinterpret_cast< wxImage * >(argp2);
18320 if (obj2) {
18321 ecode3 = SWIG_AsVal_int(obj2, &val3);
18322 if (!SWIG_IsOK(ecode3)) {
18323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18324 }
18325 arg3 = static_cast< int >(val3);
18326 }
18327 if (obj3) {
18328 ecode4 = SWIG_AsVal_int(obj3, &val4);
18329 if (!SWIG_IsOK(ecode4)) {
18330 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18331 }
18332 arg4 = static_cast< int >(val4);
18333 }
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 {
18341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18342 }
18343 return resultobj;
18344 fail:
18345 return NULL;
18346 }
18347
18348
18349 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18350 PyObject *obj;
18351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18352 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18353 return SWIG_Py_Void();
18354 }
18355
18356 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18357 PyObject *resultobj = 0;
18358 wxEvtHandler *result = 0 ;
18359
18360 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18361 {
18362 PyThreadState* __tstate = wxPyBeginAllowThreads();
18363 result = (wxEvtHandler *)new wxEvtHandler();
18364 wxPyEndAllowThreads(__tstate);
18365 if (PyErr_Occurred()) SWIG_fail;
18366 }
18367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18368 return resultobj;
18369 fail:
18370 return NULL;
18371 }
18372
18373
18374 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18375 PyObject *resultobj = 0;
18376 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18377 wxEvtHandler *result = 0 ;
18378 void *argp1 = 0 ;
18379 int res1 = 0 ;
18380 PyObject *swig_obj[1] ;
18381
18382 if (!args) SWIG_fail;
18383 swig_obj[0] = args;
18384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18385 if (!SWIG_IsOK(res1)) {
18386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18387 }
18388 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18392 wxPyEndAllowThreads(__tstate);
18393 if (PyErr_Occurred()) SWIG_fail;
18394 }
18395 {
18396 resultobj = wxPyMake_wxObject(result, 0);
18397 }
18398 return resultobj;
18399 fail:
18400 return NULL;
18401 }
18402
18403
18404 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18405 PyObject *resultobj = 0;
18406 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18407 wxEvtHandler *result = 0 ;
18408 void *argp1 = 0 ;
18409 int res1 = 0 ;
18410 PyObject *swig_obj[1] ;
18411
18412 if (!args) SWIG_fail;
18413 swig_obj[0] = args;
18414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18415 if (!SWIG_IsOK(res1)) {
18416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18417 }
18418 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18419 {
18420 PyThreadState* __tstate = wxPyBeginAllowThreads();
18421 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18422 wxPyEndAllowThreads(__tstate);
18423 if (PyErr_Occurred()) SWIG_fail;
18424 }
18425 {
18426 resultobj = wxPyMake_wxObject(result, 0);
18427 }
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj = 0;
18436 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18437 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18438 void *argp1 = 0 ;
18439 int res1 = 0 ;
18440 void *argp2 = 0 ;
18441 int res2 = 0 ;
18442 PyObject * obj0 = 0 ;
18443 PyObject * obj1 = 0 ;
18444 char * kwnames[] = {
18445 (char *) "self",(char *) "handler", NULL
18446 };
18447
18448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18450 if (!SWIG_IsOK(res1)) {
18451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18452 }
18453 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18455 if (!SWIG_IsOK(res2)) {
18456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18457 }
18458 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18459 {
18460 PyThreadState* __tstate = wxPyBeginAllowThreads();
18461 (arg1)->SetNextHandler(arg2);
18462 wxPyEndAllowThreads(__tstate);
18463 if (PyErr_Occurred()) SWIG_fail;
18464 }
18465 resultobj = SWIG_Py_Void();
18466 return resultobj;
18467 fail:
18468 return NULL;
18469 }
18470
18471
18472 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18473 PyObject *resultobj = 0;
18474 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18475 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18476 void *argp1 = 0 ;
18477 int res1 = 0 ;
18478 void *argp2 = 0 ;
18479 int res2 = 0 ;
18480 PyObject * obj0 = 0 ;
18481 PyObject * obj1 = 0 ;
18482 char * kwnames[] = {
18483 (char *) "self",(char *) "handler", NULL
18484 };
18485
18486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18488 if (!SWIG_IsOK(res1)) {
18489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18490 }
18491 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18493 if (!SWIG_IsOK(res2)) {
18494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18495 }
18496 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18497 {
18498 PyThreadState* __tstate = wxPyBeginAllowThreads();
18499 (arg1)->SetPreviousHandler(arg2);
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 resultobj = SWIG_Py_Void();
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18511 PyObject *resultobj = 0;
18512 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18513 bool result;
18514 void *argp1 = 0 ;
18515 int res1 = 0 ;
18516 PyObject *swig_obj[1] ;
18517
18518 if (!args) SWIG_fail;
18519 swig_obj[0] = args;
18520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18521 if (!SWIG_IsOK(res1)) {
18522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18523 }
18524 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18525 {
18526 PyThreadState* __tstate = wxPyBeginAllowThreads();
18527 result = (bool)(arg1)->GetEvtHandlerEnabled();
18528 wxPyEndAllowThreads(__tstate);
18529 if (PyErr_Occurred()) SWIG_fail;
18530 }
18531 {
18532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18533 }
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj = 0;
18542 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18543 bool arg2 ;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 bool val2 ;
18547 int ecode2 = 0 ;
18548 PyObject * obj0 = 0 ;
18549 PyObject * obj1 = 0 ;
18550 char * kwnames[] = {
18551 (char *) "self",(char *) "enabled", NULL
18552 };
18553
18554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18556 if (!SWIG_IsOK(res1)) {
18557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18558 }
18559 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18561 if (!SWIG_IsOK(ecode2)) {
18562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18563 }
18564 arg2 = static_cast< bool >(val2);
18565 {
18566 PyThreadState* __tstate = wxPyBeginAllowThreads();
18567 (arg1)->SetEvtHandlerEnabled(arg2);
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 resultobj = SWIG_Py_Void();
18572 return resultobj;
18573 fail:
18574 return NULL;
18575 }
18576
18577
18578 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18579 PyObject *resultobj = 0;
18580 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18581 wxEvent *arg2 = 0 ;
18582 bool result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 void *argp2 = 0 ;
18586 int res2 = 0 ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 char * kwnames[] = {
18590 (char *) "self",(char *) "event", NULL
18591 };
18592
18593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18595 if (!SWIG_IsOK(res1)) {
18596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18597 }
18598 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18599 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18600 if (!SWIG_IsOK(res2)) {
18601 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18602 }
18603 if (!argp2) {
18604 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18605 }
18606 arg2 = reinterpret_cast< wxEvent * >(argp2);
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 result = (bool)(arg1)->ProcessEvent(*arg2);
18610 wxPyEndAllowThreads(__tstate);
18611 if (PyErr_Occurred()) SWIG_fail;
18612 }
18613 {
18614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18615 }
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18623 PyObject *resultobj = 0;
18624 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18625 wxEvent *arg2 = 0 ;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 void *argp2 = 0 ;
18629 int res2 = 0 ;
18630 PyObject * obj0 = 0 ;
18631 PyObject * obj1 = 0 ;
18632 char * kwnames[] = {
18633 (char *) "self",(char *) "event", NULL
18634 };
18635
18636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18642 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18643 if (!SWIG_IsOK(res2)) {
18644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18645 }
18646 if (!argp2) {
18647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18648 }
18649 arg2 = reinterpret_cast< wxEvent * >(argp2);
18650 {
18651 PyThreadState* __tstate = wxPyBeginAllowThreads();
18652 (arg1)->AddPendingEvent(*arg2);
18653 wxPyEndAllowThreads(__tstate);
18654 if (PyErr_Occurred()) SWIG_fail;
18655 }
18656 resultobj = SWIG_Py_Void();
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18664 PyObject *resultobj = 0;
18665 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18666 void *argp1 = 0 ;
18667 int res1 = 0 ;
18668 PyObject *swig_obj[1] ;
18669
18670 if (!args) SWIG_fail;
18671 swig_obj[0] = args;
18672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18673 if (!SWIG_IsOK(res1)) {
18674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18675 }
18676 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 (arg1)->ProcessPendingEvents();
18680 wxPyEndAllowThreads(__tstate);
18681 if (PyErr_Occurred()) SWIG_fail;
18682 }
18683 resultobj = SWIG_Py_Void();
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj = 0;
18692 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18693 bool arg2 = (bool) true ;
18694 void *argp1 = 0 ;
18695 int res1 = 0 ;
18696 bool val2 ;
18697 int ecode2 = 0 ;
18698 PyObject * obj0 = 0 ;
18699 PyObject * obj1 = 0 ;
18700 char * kwnames[] = {
18701 (char *) "self",(char *) "allow", NULL
18702 };
18703
18704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18706 if (!SWIG_IsOK(res1)) {
18707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18708 }
18709 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18710 if (obj1) {
18711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18712 if (!SWIG_IsOK(ecode2)) {
18713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18714 }
18715 arg2 = static_cast< bool >(val2);
18716 }
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 (arg1)->AllowReentrance(arg2);
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 resultobj = SWIG_Py_Void();
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18731 PyObject *resultobj = 0;
18732 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18733 bool result;
18734 void *argp1 = 0 ;
18735 int res1 = 0 ;
18736 PyObject *swig_obj[1] ;
18737
18738 if (!args) SWIG_fail;
18739 swig_obj[0] = args;
18740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18741 if (!SWIG_IsOK(res1)) {
18742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18743 }
18744 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18745 {
18746 PyThreadState* __tstate = wxPyBeginAllowThreads();
18747 result = (bool)(arg1)->IsReentranceAllowed();
18748 wxPyEndAllowThreads(__tstate);
18749 if (PyErr_Occurred()) SWIG_fail;
18750 }
18751 {
18752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18753 }
18754 return resultobj;
18755 fail:
18756 return NULL;
18757 }
18758
18759
18760 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18761 PyObject *resultobj = 0;
18762 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18763 bool result;
18764 void *argp1 = 0 ;
18765 int res1 = 0 ;
18766 PyObject *swig_obj[1] ;
18767
18768 if (!args) SWIG_fail;
18769 swig_obj[0] = args;
18770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18771 if (!SWIG_IsOK(res1)) {
18772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18773 }
18774 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 result = (bool)(arg1)->IsEventHandlingInProgress();
18778 wxPyEndAllowThreads(__tstate);
18779 if (PyErr_Occurred()) SWIG_fail;
18780 }
18781 {
18782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18783 }
18784 return resultobj;
18785 fail:
18786 return NULL;
18787 }
18788
18789
18790 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18791 PyObject *resultobj = 0;
18792 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18793 int arg2 ;
18794 int arg3 ;
18795 int arg4 ;
18796 PyObject *arg5 = (PyObject *) 0 ;
18797 void *argp1 = 0 ;
18798 int res1 = 0 ;
18799 int val2 ;
18800 int ecode2 = 0 ;
18801 int val3 ;
18802 int ecode3 = 0 ;
18803 int val4 ;
18804 int ecode4 = 0 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 PyObject * obj2 = 0 ;
18808 PyObject * obj3 = 0 ;
18809 PyObject * obj4 = 0 ;
18810 char * kwnames[] = {
18811 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18812 };
18813
18814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18816 if (!SWIG_IsOK(res1)) {
18817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18818 }
18819 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18820 ecode2 = SWIG_AsVal_int(obj1, &val2);
18821 if (!SWIG_IsOK(ecode2)) {
18822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18823 }
18824 arg2 = static_cast< int >(val2);
18825 ecode3 = SWIG_AsVal_int(obj2, &val3);
18826 if (!SWIG_IsOK(ecode3)) {
18827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18828 }
18829 arg3 = static_cast< int >(val3);
18830 ecode4 = SWIG_AsVal_int(obj3, &val4);
18831 if (!SWIG_IsOK(ecode4)) {
18832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18833 }
18834 arg4 = static_cast< int >(val4);
18835 arg5 = obj4;
18836 {
18837 PyThreadState* __tstate = wxPyBeginAllowThreads();
18838 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18839 wxPyEndAllowThreads(__tstate);
18840 if (PyErr_Occurred()) SWIG_fail;
18841 }
18842 resultobj = SWIG_Py_Void();
18843 return resultobj;
18844 fail:
18845 return NULL;
18846 }
18847
18848
18849 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18850 PyObject *resultobj = 0;
18851 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18852 int arg2 ;
18853 int arg3 = (int) -1 ;
18854 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18855 bool result;
18856 void *argp1 = 0 ;
18857 int res1 = 0 ;
18858 int val2 ;
18859 int ecode2 = 0 ;
18860 int val3 ;
18861 int ecode3 = 0 ;
18862 int val4 ;
18863 int ecode4 = 0 ;
18864 PyObject * obj0 = 0 ;
18865 PyObject * obj1 = 0 ;
18866 PyObject * obj2 = 0 ;
18867 PyObject * obj3 = 0 ;
18868 char * kwnames[] = {
18869 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18870 };
18871
18872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18874 if (!SWIG_IsOK(res1)) {
18875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18876 }
18877 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18878 ecode2 = SWIG_AsVal_int(obj1, &val2);
18879 if (!SWIG_IsOK(ecode2)) {
18880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18881 }
18882 arg2 = static_cast< int >(val2);
18883 if (obj2) {
18884 ecode3 = SWIG_AsVal_int(obj2, &val3);
18885 if (!SWIG_IsOK(ecode3)) {
18886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18887 }
18888 arg3 = static_cast< int >(val3);
18889 }
18890 if (obj3) {
18891 ecode4 = SWIG_AsVal_int(obj3, &val4);
18892 if (!SWIG_IsOK(ecode4)) {
18893 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18894 }
18895 arg4 = static_cast< wxEventType >(val4);
18896 }
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 {
18904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18905 }
18906 return resultobj;
18907 fail:
18908 return NULL;
18909 }
18910
18911
18912 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18913 PyObject *resultobj = 0;
18914 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18915 PyObject *arg2 = (PyObject *) 0 ;
18916 bool arg3 = (bool) true ;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 bool val3 ;
18920 int ecode3 = 0 ;
18921 PyObject * obj0 = 0 ;
18922 PyObject * obj1 = 0 ;
18923 PyObject * obj2 = 0 ;
18924 char * kwnames[] = {
18925 (char *) "self",(char *) "_self",(char *) "incref", NULL
18926 };
18927
18928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18930 if (!SWIG_IsOK(res1)) {
18931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18932 }
18933 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18934 arg2 = obj1;
18935 if (obj2) {
18936 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18937 if (!SWIG_IsOK(ecode3)) {
18938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18939 }
18940 arg3 = static_cast< bool >(val3);
18941 }
18942 {
18943 PyThreadState* __tstate = wxPyBeginAllowThreads();
18944 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18945 wxPyEndAllowThreads(__tstate);
18946 if (PyErr_Occurred()) SWIG_fail;
18947 }
18948 resultobj = SWIG_Py_Void();
18949 return resultobj;
18950 fail:
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18956 PyObject *obj;
18957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18958 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18959 return SWIG_Py_Void();
18960 }
18961
18962 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18963 return SWIG_Python_InitShadowInstance(args);
18964 }
18965
18966 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18967 PyObject *resultobj = 0;
18968 wxEventType result;
18969
18970 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 result = (wxEventType)wxNewEventType();
18974 wxPyEndAllowThreads(__tstate);
18975 if (PyErr_Occurred()) SWIG_fail;
18976 }
18977 resultobj = SWIG_From_int(static_cast< int >(result));
18978 return resultobj;
18979 fail:
18980 return NULL;
18981 }
18982
18983
18984 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18985 PyObject *resultobj = 0;
18986 wxEvent *arg1 = (wxEvent *) 0 ;
18987 void *argp1 = 0 ;
18988 int res1 = 0 ;
18989 PyObject *swig_obj[1] ;
18990
18991 if (!args) SWIG_fail;
18992 swig_obj[0] = args;
18993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18994 if (!SWIG_IsOK(res1)) {
18995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18996 }
18997 arg1 = reinterpret_cast< wxEvent * >(argp1);
18998 {
18999 PyThreadState* __tstate = wxPyBeginAllowThreads();
19000 delete arg1;
19001
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 resultobj = SWIG_Py_Void();
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = 0;
19014 wxEvent *arg1 = (wxEvent *) 0 ;
19015 wxEventType arg2 ;
19016 void *argp1 = 0 ;
19017 int res1 = 0 ;
19018 int val2 ;
19019 int ecode2 = 0 ;
19020 PyObject * obj0 = 0 ;
19021 PyObject * obj1 = 0 ;
19022 char * kwnames[] = {
19023 (char *) "self",(char *) "typ", NULL
19024 };
19025
19026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19028 if (!SWIG_IsOK(res1)) {
19029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19030 }
19031 arg1 = reinterpret_cast< wxEvent * >(argp1);
19032 ecode2 = SWIG_AsVal_int(obj1, &val2);
19033 if (!SWIG_IsOK(ecode2)) {
19034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19035 }
19036 arg2 = static_cast< wxEventType >(val2);
19037 {
19038 PyThreadState* __tstate = wxPyBeginAllowThreads();
19039 (arg1)->SetEventType(arg2);
19040 wxPyEndAllowThreads(__tstate);
19041 if (PyErr_Occurred()) SWIG_fail;
19042 }
19043 resultobj = SWIG_Py_Void();
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19051 PyObject *resultobj = 0;
19052 wxEvent *arg1 = (wxEvent *) 0 ;
19053 wxEventType result;
19054 void *argp1 = 0 ;
19055 int res1 = 0 ;
19056 PyObject *swig_obj[1] ;
19057
19058 if (!args) SWIG_fail;
19059 swig_obj[0] = args;
19060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19061 if (!SWIG_IsOK(res1)) {
19062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19063 }
19064 arg1 = reinterpret_cast< wxEvent * >(argp1);
19065 {
19066 PyThreadState* __tstate = wxPyBeginAllowThreads();
19067 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19068 wxPyEndAllowThreads(__tstate);
19069 if (PyErr_Occurred()) SWIG_fail;
19070 }
19071 resultobj = SWIG_From_int(static_cast< int >(result));
19072 return resultobj;
19073 fail:
19074 return NULL;
19075 }
19076
19077
19078 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19079 PyObject *resultobj = 0;
19080 wxEvent *arg1 = (wxEvent *) 0 ;
19081 wxObject *result = 0 ;
19082 void *argp1 = 0 ;
19083 int res1 = 0 ;
19084 PyObject *swig_obj[1] ;
19085
19086 if (!args) SWIG_fail;
19087 swig_obj[0] = args;
19088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19089 if (!SWIG_IsOK(res1)) {
19090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19091 }
19092 arg1 = reinterpret_cast< wxEvent * >(argp1);
19093 {
19094 PyThreadState* __tstate = wxPyBeginAllowThreads();
19095 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19096 wxPyEndAllowThreads(__tstate);
19097 if (PyErr_Occurred()) SWIG_fail;
19098 }
19099 {
19100 resultobj = wxPyMake_wxObject(result, (bool)0);
19101 }
19102 return resultobj;
19103 fail:
19104 return NULL;
19105 }
19106
19107
19108 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19109 PyObject *resultobj = 0;
19110 wxEvent *arg1 = (wxEvent *) 0 ;
19111 wxObject *arg2 = (wxObject *) 0 ;
19112 void *argp1 = 0 ;
19113 int res1 = 0 ;
19114 void *argp2 = 0 ;
19115 int res2 = 0 ;
19116 PyObject * obj0 = 0 ;
19117 PyObject * obj1 = 0 ;
19118 char * kwnames[] = {
19119 (char *) "self",(char *) "obj", NULL
19120 };
19121
19122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19124 if (!SWIG_IsOK(res1)) {
19125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19126 }
19127 arg1 = reinterpret_cast< wxEvent * >(argp1);
19128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19129 if (!SWIG_IsOK(res2)) {
19130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19131 }
19132 arg2 = reinterpret_cast< wxObject * >(argp2);
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 (arg1)->SetEventObject(arg2);
19136 wxPyEndAllowThreads(__tstate);
19137 if (PyErr_Occurred()) SWIG_fail;
19138 }
19139 resultobj = SWIG_Py_Void();
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19147 PyObject *resultobj = 0;
19148 wxEvent *arg1 = (wxEvent *) 0 ;
19149 long result;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 PyObject *swig_obj[1] ;
19153
19154 if (!args) SWIG_fail;
19155 swig_obj[0] = args;
19156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19157 if (!SWIG_IsOK(res1)) {
19158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19159 }
19160 arg1 = reinterpret_cast< wxEvent * >(argp1);
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = SWIG_From_long(static_cast< long >(result));
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19175 PyObject *resultobj = 0;
19176 wxEvent *arg1 = (wxEvent *) 0 ;
19177 long arg2 = (long) 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 long val2 ;
19181 int ecode2 = 0 ;
19182 PyObject * obj0 = 0 ;
19183 PyObject * obj1 = 0 ;
19184 char * kwnames[] = {
19185 (char *) "self",(char *) "ts", NULL
19186 };
19187
19188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19190 if (!SWIG_IsOK(res1)) {
19191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19192 }
19193 arg1 = reinterpret_cast< wxEvent * >(argp1);
19194 if (obj1) {
19195 ecode2 = SWIG_AsVal_long(obj1, &val2);
19196 if (!SWIG_IsOK(ecode2)) {
19197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19198 }
19199 arg2 = static_cast< long >(val2);
19200 }
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 (arg1)->SetTimestamp(arg2);
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 resultobj = SWIG_Py_Void();
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19215 PyObject *resultobj = 0;
19216 wxEvent *arg1 = (wxEvent *) 0 ;
19217 int result;
19218 void *argp1 = 0 ;
19219 int res1 = 0 ;
19220 PyObject *swig_obj[1] ;
19221
19222 if (!args) SWIG_fail;
19223 swig_obj[0] = args;
19224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19225 if (!SWIG_IsOK(res1)) {
19226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19227 }
19228 arg1 = reinterpret_cast< wxEvent * >(argp1);
19229 {
19230 PyThreadState* __tstate = wxPyBeginAllowThreads();
19231 result = (int)((wxEvent const *)arg1)->GetId();
19232 wxPyEndAllowThreads(__tstate);
19233 if (PyErr_Occurred()) SWIG_fail;
19234 }
19235 resultobj = SWIG_From_int(static_cast< int >(result));
19236 return resultobj;
19237 fail:
19238 return NULL;
19239 }
19240
19241
19242 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19243 PyObject *resultobj = 0;
19244 wxEvent *arg1 = (wxEvent *) 0 ;
19245 int arg2 ;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 int val2 ;
19249 int ecode2 = 0 ;
19250 PyObject * obj0 = 0 ;
19251 PyObject * obj1 = 0 ;
19252 char * kwnames[] = {
19253 (char *) "self",(char *) "Id", NULL
19254 };
19255
19256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19258 if (!SWIG_IsOK(res1)) {
19259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19260 }
19261 arg1 = reinterpret_cast< wxEvent * >(argp1);
19262 ecode2 = SWIG_AsVal_int(obj1, &val2);
19263 if (!SWIG_IsOK(ecode2)) {
19264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19265 }
19266 arg2 = static_cast< int >(val2);
19267 {
19268 PyThreadState* __tstate = wxPyBeginAllowThreads();
19269 (arg1)->SetId(arg2);
19270 wxPyEndAllowThreads(__tstate);
19271 if (PyErr_Occurred()) SWIG_fail;
19272 }
19273 resultobj = SWIG_Py_Void();
19274 return resultobj;
19275 fail:
19276 return NULL;
19277 }
19278
19279
19280 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19281 PyObject *resultobj = 0;
19282 wxEvent *arg1 = (wxEvent *) 0 ;
19283 bool result;
19284 void *argp1 = 0 ;
19285 int res1 = 0 ;
19286 PyObject *swig_obj[1] ;
19287
19288 if (!args) SWIG_fail;
19289 swig_obj[0] = args;
19290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19291 if (!SWIG_IsOK(res1)) {
19292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19293 }
19294 arg1 = reinterpret_cast< wxEvent * >(argp1);
19295 {
19296 PyThreadState* __tstate = wxPyBeginAllowThreads();
19297 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19298 wxPyEndAllowThreads(__tstate);
19299 if (PyErr_Occurred()) SWIG_fail;
19300 }
19301 {
19302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19303 }
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19311 PyObject *resultobj = 0;
19312 wxEvent *arg1 = (wxEvent *) 0 ;
19313 bool arg2 = (bool) true ;
19314 void *argp1 = 0 ;
19315 int res1 = 0 ;
19316 bool val2 ;
19317 int ecode2 = 0 ;
19318 PyObject * obj0 = 0 ;
19319 PyObject * obj1 = 0 ;
19320 char * kwnames[] = {
19321 (char *) "self",(char *) "skip", NULL
19322 };
19323
19324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19326 if (!SWIG_IsOK(res1)) {
19327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19328 }
19329 arg1 = reinterpret_cast< wxEvent * >(argp1);
19330 if (obj1) {
19331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19332 if (!SWIG_IsOK(ecode2)) {
19333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19334 }
19335 arg2 = static_cast< bool >(val2);
19336 }
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 (arg1)->Skip(arg2);
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_Py_Void();
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxEvent *arg1 = (wxEvent *) 0 ;
19353 bool result;
19354 void *argp1 = 0 ;
19355 int res1 = 0 ;
19356 PyObject *swig_obj[1] ;
19357
19358 if (!args) SWIG_fail;
19359 swig_obj[0] = args;
19360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19363 }
19364 arg1 = reinterpret_cast< wxEvent * >(argp1);
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 {
19372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19373 }
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19381 PyObject *resultobj = 0;
19382 wxEvent *arg1 = (wxEvent *) 0 ;
19383 bool result;
19384 void *argp1 = 0 ;
19385 int res1 = 0 ;
19386 PyObject *swig_obj[1] ;
19387
19388 if (!args) SWIG_fail;
19389 swig_obj[0] = args;
19390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19391 if (!SWIG_IsOK(res1)) {
19392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19393 }
19394 arg1 = reinterpret_cast< wxEvent * >(argp1);
19395 {
19396 PyThreadState* __tstate = wxPyBeginAllowThreads();
19397 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19398 wxPyEndAllowThreads(__tstate);
19399 if (PyErr_Occurred()) SWIG_fail;
19400 }
19401 {
19402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19403 }
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxEvent *arg1 = (wxEvent *) 0 ;
19413 int result;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19423 }
19424 arg1 = reinterpret_cast< wxEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (int)(arg1)->StopPropagation();
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 resultobj = SWIG_From_int(static_cast< int >(result));
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19439 PyObject *resultobj = 0;
19440 wxEvent *arg1 = (wxEvent *) 0 ;
19441 int arg2 ;
19442 void *argp1 = 0 ;
19443 int res1 = 0 ;
19444 int val2 ;
19445 int ecode2 = 0 ;
19446 PyObject * obj0 = 0 ;
19447 PyObject * obj1 = 0 ;
19448 char * kwnames[] = {
19449 (char *) "self",(char *) "propagationLevel", NULL
19450 };
19451
19452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19454 if (!SWIG_IsOK(res1)) {
19455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19456 }
19457 arg1 = reinterpret_cast< wxEvent * >(argp1);
19458 ecode2 = SWIG_AsVal_int(obj1, &val2);
19459 if (!SWIG_IsOK(ecode2)) {
19460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19461 }
19462 arg2 = static_cast< int >(val2);
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 (arg1)->ResumePropagation(arg2);
19466 wxPyEndAllowThreads(__tstate);
19467 if (PyErr_Occurred()) SWIG_fail;
19468 }
19469 resultobj = SWIG_Py_Void();
19470 return resultobj;
19471 fail:
19472 return NULL;
19473 }
19474
19475
19476 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19477 PyObject *resultobj = 0;
19478 wxEvent *arg1 = (wxEvent *) 0 ;
19479 wxEvent *result = 0 ;
19480 void *argp1 = 0 ;
19481 int res1 = 0 ;
19482 PyObject *swig_obj[1] ;
19483
19484 if (!args) SWIG_fail;
19485 swig_obj[0] = args;
19486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19489 }
19490 arg1 = reinterpret_cast< wxEvent * >(argp1);
19491 {
19492 PyThreadState* __tstate = wxPyBeginAllowThreads();
19493 result = (wxEvent *)(arg1)->Clone();
19494 wxPyEndAllowThreads(__tstate);
19495 if (PyErr_Occurred()) SWIG_fail;
19496 }
19497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19505 PyObject *obj;
19506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19507 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19508 return SWIG_Py_Void();
19509 }
19510
19511 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19512 PyObject *resultobj = 0;
19513 wxEvent *arg1 = 0 ;
19514 wxPropagationDisabler *result = 0 ;
19515 void *argp1 = 0 ;
19516 int res1 = 0 ;
19517 PyObject * obj0 = 0 ;
19518 char * kwnames[] = {
19519 (char *) "event", NULL
19520 };
19521
19522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19523 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19524 if (!SWIG_IsOK(res1)) {
19525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19526 }
19527 if (!argp1) {
19528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19529 }
19530 arg1 = reinterpret_cast< wxEvent * >(argp1);
19531 {
19532 PyThreadState* __tstate = wxPyBeginAllowThreads();
19533 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19534 wxPyEndAllowThreads(__tstate);
19535 if (PyErr_Occurred()) SWIG_fail;
19536 }
19537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19545 PyObject *resultobj = 0;
19546 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19547 void *argp1 = 0 ;
19548 int res1 = 0 ;
19549 PyObject *swig_obj[1] ;
19550
19551 if (!args) SWIG_fail;
19552 swig_obj[0] = args;
19553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19554 if (!SWIG_IsOK(res1)) {
19555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19556 }
19557 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 delete arg1;
19561
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 resultobj = SWIG_Py_Void();
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19573 PyObject *obj;
19574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19575 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19576 return SWIG_Py_Void();
19577 }
19578
19579 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19580 return SWIG_Python_InitShadowInstance(args);
19581 }
19582
19583 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19584 PyObject *resultobj = 0;
19585 wxEvent *arg1 = 0 ;
19586 wxPropagateOnce *result = 0 ;
19587 void *argp1 = 0 ;
19588 int res1 = 0 ;
19589 PyObject * obj0 = 0 ;
19590 char * kwnames[] = {
19591 (char *) "event", NULL
19592 };
19593
19594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19595 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19596 if (!SWIG_IsOK(res1)) {
19597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19598 }
19599 if (!argp1) {
19600 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19601 }
19602 arg1 = reinterpret_cast< wxEvent * >(argp1);
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617 PyObject *resultobj = 0;
19618 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19619 void *argp1 = 0 ;
19620 int res1 = 0 ;
19621 PyObject *swig_obj[1] ;
19622
19623 if (!args) SWIG_fail;
19624 swig_obj[0] = args;
19625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19626 if (!SWIG_IsOK(res1)) {
19627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19628 }
19629 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19630 {
19631 PyThreadState* __tstate = wxPyBeginAllowThreads();
19632 delete arg1;
19633
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_Py_Void();
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *obj;
19646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19647 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19648 return SWIG_Py_Void();
19649 }
19650
19651 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19652 return SWIG_Python_InitShadowInstance(args);
19653 }
19654
19655 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19656 PyObject *resultobj = 0;
19657 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19658 int arg2 = (int) 0 ;
19659 wxCommandEvent *result = 0 ;
19660 int val1 ;
19661 int ecode1 = 0 ;
19662 int val2 ;
19663 int ecode2 = 0 ;
19664 PyObject * obj0 = 0 ;
19665 PyObject * obj1 = 0 ;
19666 char * kwnames[] = {
19667 (char *) "commandType",(char *) "winid", NULL
19668 };
19669
19670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19671 if (obj0) {
19672 ecode1 = SWIG_AsVal_int(obj0, &val1);
19673 if (!SWIG_IsOK(ecode1)) {
19674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19675 }
19676 arg1 = static_cast< wxEventType >(val1);
19677 }
19678 if (obj1) {
19679 ecode2 = SWIG_AsVal_int(obj1, &val2);
19680 if (!SWIG_IsOK(ecode2)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19682 }
19683 arg2 = static_cast< int >(val2);
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19692 return resultobj;
19693 fail:
19694 return NULL;
19695 }
19696
19697
19698 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19699 PyObject *resultobj = 0;
19700 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19701 int result;
19702 void *argp1 = 0 ;
19703 int res1 = 0 ;
19704 PyObject *swig_obj[1] ;
19705
19706 if (!args) SWIG_fail;
19707 swig_obj[0] = args;
19708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19709 if (!SWIG_IsOK(res1)) {
19710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19711 }
19712 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19716 wxPyEndAllowThreads(__tstate);
19717 if (PyErr_Occurred()) SWIG_fail;
19718 }
19719 resultobj = SWIG_From_int(static_cast< int >(result));
19720 return resultobj;
19721 fail:
19722 return NULL;
19723 }
19724
19725
19726 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19727 PyObject *resultobj = 0;
19728 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19729 wxString *arg2 = 0 ;
19730 void *argp1 = 0 ;
19731 int res1 = 0 ;
19732 bool temp2 = false ;
19733 PyObject * obj0 = 0 ;
19734 PyObject * obj1 = 0 ;
19735 char * kwnames[] = {
19736 (char *) "self",(char *) "s", NULL
19737 };
19738
19739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19741 if (!SWIG_IsOK(res1)) {
19742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19743 }
19744 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19745 {
19746 arg2 = wxString_in_helper(obj1);
19747 if (arg2 == NULL) SWIG_fail;
19748 temp2 = true;
19749 }
19750 {
19751 PyThreadState* __tstate = wxPyBeginAllowThreads();
19752 (arg1)->SetString((wxString const &)*arg2);
19753 wxPyEndAllowThreads(__tstate);
19754 if (PyErr_Occurred()) SWIG_fail;
19755 }
19756 resultobj = SWIG_Py_Void();
19757 {
19758 if (temp2)
19759 delete arg2;
19760 }
19761 return resultobj;
19762 fail:
19763 {
19764 if (temp2)
19765 delete arg2;
19766 }
19767 return NULL;
19768 }
19769
19770
19771 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19772 PyObject *resultobj = 0;
19773 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19774 wxString result;
19775 void *argp1 = 0 ;
19776 int res1 = 0 ;
19777 PyObject *swig_obj[1] ;
19778
19779 if (!args) SWIG_fail;
19780 swig_obj[0] = args;
19781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19782 if (!SWIG_IsOK(res1)) {
19783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19784 }
19785 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19786 {
19787 PyThreadState* __tstate = wxPyBeginAllowThreads();
19788 result = ((wxCommandEvent const *)arg1)->GetString();
19789 wxPyEndAllowThreads(__tstate);
19790 if (PyErr_Occurred()) SWIG_fail;
19791 }
19792 {
19793 #if wxUSE_UNICODE
19794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19795 #else
19796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19797 #endif
19798 }
19799 return resultobj;
19800 fail:
19801 return NULL;
19802 }
19803
19804
19805 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19806 PyObject *resultobj = 0;
19807 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19808 bool result;
19809 void *argp1 = 0 ;
19810 int res1 = 0 ;
19811 PyObject *swig_obj[1] ;
19812
19813 if (!args) SWIG_fail;
19814 swig_obj[0] = args;
19815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19816 if (!SWIG_IsOK(res1)) {
19817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19818 }
19819 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19820 {
19821 PyThreadState* __tstate = wxPyBeginAllowThreads();
19822 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19823 wxPyEndAllowThreads(__tstate);
19824 if (PyErr_Occurred()) SWIG_fail;
19825 }
19826 {
19827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19828 }
19829 return resultobj;
19830 fail:
19831 return NULL;
19832 }
19833
19834
19835 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19836 PyObject *resultobj = 0;
19837 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19838 bool result;
19839 void *argp1 = 0 ;
19840 int res1 = 0 ;
19841 PyObject *swig_obj[1] ;
19842
19843 if (!args) SWIG_fail;
19844 swig_obj[0] = args;
19845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19846 if (!SWIG_IsOK(res1)) {
19847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19848 }
19849 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19850 {
19851 PyThreadState* __tstate = wxPyBeginAllowThreads();
19852 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19853 wxPyEndAllowThreads(__tstate);
19854 if (PyErr_Occurred()) SWIG_fail;
19855 }
19856 {
19857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19858 }
19859 return resultobj;
19860 fail:
19861 return NULL;
19862 }
19863
19864
19865 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19866 PyObject *resultobj = 0;
19867 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19868 long arg2 ;
19869 void *argp1 = 0 ;
19870 int res1 = 0 ;
19871 long val2 ;
19872 int ecode2 = 0 ;
19873 PyObject * obj0 = 0 ;
19874 PyObject * obj1 = 0 ;
19875 char * kwnames[] = {
19876 (char *) "self",(char *) "extraLong", NULL
19877 };
19878
19879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19881 if (!SWIG_IsOK(res1)) {
19882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19883 }
19884 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19885 ecode2 = SWIG_AsVal_long(obj1, &val2);
19886 if (!SWIG_IsOK(ecode2)) {
19887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19888 }
19889 arg2 = static_cast< long >(val2);
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 (arg1)->SetExtraLong(arg2);
19893 wxPyEndAllowThreads(__tstate);
19894 if (PyErr_Occurred()) SWIG_fail;
19895 }
19896 resultobj = SWIG_Py_Void();
19897 return resultobj;
19898 fail:
19899 return NULL;
19900 }
19901
19902
19903 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19904 PyObject *resultobj = 0;
19905 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19906 long result;
19907 void *argp1 = 0 ;
19908 int res1 = 0 ;
19909 PyObject *swig_obj[1] ;
19910
19911 if (!args) SWIG_fail;
19912 swig_obj[0] = args;
19913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19914 if (!SWIG_IsOK(res1)) {
19915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19916 }
19917 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19918 {
19919 PyThreadState* __tstate = wxPyBeginAllowThreads();
19920 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19921 wxPyEndAllowThreads(__tstate);
19922 if (PyErr_Occurred()) SWIG_fail;
19923 }
19924 resultobj = SWIG_From_long(static_cast< long >(result));
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19932 PyObject *resultobj = 0;
19933 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19934 int arg2 ;
19935 void *argp1 = 0 ;
19936 int res1 = 0 ;
19937 int val2 ;
19938 int ecode2 = 0 ;
19939 PyObject * obj0 = 0 ;
19940 PyObject * obj1 = 0 ;
19941 char * kwnames[] = {
19942 (char *) "self",(char *) "i", NULL
19943 };
19944
19945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19947 if (!SWIG_IsOK(res1)) {
19948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19949 }
19950 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19951 ecode2 = SWIG_AsVal_int(obj1, &val2);
19952 if (!SWIG_IsOK(ecode2)) {
19953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19954 }
19955 arg2 = static_cast< int >(val2);
19956 {
19957 PyThreadState* __tstate = wxPyBeginAllowThreads();
19958 (arg1)->SetInt(arg2);
19959 wxPyEndAllowThreads(__tstate);
19960 if (PyErr_Occurred()) SWIG_fail;
19961 }
19962 resultobj = SWIG_Py_Void();
19963 return resultobj;
19964 fail:
19965 return NULL;
19966 }
19967
19968
19969 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19970 PyObject *resultobj = 0;
19971 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19972 int result;
19973 void *argp1 = 0 ;
19974 int res1 = 0 ;
19975 PyObject *swig_obj[1] ;
19976
19977 if (!args) SWIG_fail;
19978 swig_obj[0] = args;
19979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19980 if (!SWIG_IsOK(res1)) {
19981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19982 }
19983 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_From_int(static_cast< int >(result));
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19998 PyObject *resultobj = 0;
19999 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20000 PyObject *result = 0 ;
20001 void *argp1 = 0 ;
20002 int res1 = 0 ;
20003 PyObject *swig_obj[1] ;
20004
20005 if (!args) SWIG_fail;
20006 swig_obj[0] = args;
20007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20008 if (!SWIG_IsOK(res1)) {
20009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20010 }
20011 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20015 wxPyEndAllowThreads(__tstate);
20016 if (PyErr_Occurred()) SWIG_fail;
20017 }
20018 resultobj = result;
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20026 PyObject *resultobj = 0;
20027 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20028 PyObject *arg2 = (PyObject *) 0 ;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "self",(char *) "clientData", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20041 }
20042 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20043 arg2 = obj1;
20044 {
20045 PyThreadState* __tstate = wxPyBeginAllowThreads();
20046 wxCommandEvent_SetClientData(arg1,arg2);
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_Py_Void();
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20058 PyObject *resultobj = 0;
20059 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20060 wxEvent *result = 0 ;
20061 void *argp1 = 0 ;
20062 int res1 = 0 ;
20063 PyObject *swig_obj[1] ;
20064
20065 if (!args) SWIG_fail;
20066 swig_obj[0] = args;
20067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20068 if (!SWIG_IsOK(res1)) {
20069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20070 }
20071 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20079 return resultobj;
20080 fail:
20081 return NULL;
20082 }
20083
20084
20085 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20086 PyObject *obj;
20087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20088 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20089 return SWIG_Py_Void();
20090 }
20091
20092 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093 return SWIG_Python_InitShadowInstance(args);
20094 }
20095
20096 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20097 PyObject *resultobj = 0;
20098 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20099 int arg2 = (int) 0 ;
20100 wxNotifyEvent *result = 0 ;
20101 int val1 ;
20102 int ecode1 = 0 ;
20103 int val2 ;
20104 int ecode2 = 0 ;
20105 PyObject * obj0 = 0 ;
20106 PyObject * obj1 = 0 ;
20107 char * kwnames[] = {
20108 (char *) "commandType",(char *) "winid", NULL
20109 };
20110
20111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20112 if (obj0) {
20113 ecode1 = SWIG_AsVal_int(obj0, &val1);
20114 if (!SWIG_IsOK(ecode1)) {
20115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20116 }
20117 arg1 = static_cast< wxEventType >(val1);
20118 }
20119 if (obj1) {
20120 ecode2 = SWIG_AsVal_int(obj1, &val2);
20121 if (!SWIG_IsOK(ecode2)) {
20122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20123 }
20124 arg2 = static_cast< int >(val2);
20125 }
20126 {
20127 PyThreadState* __tstate = wxPyBeginAllowThreads();
20128 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20129 wxPyEndAllowThreads(__tstate);
20130 if (PyErr_Occurred()) SWIG_fail;
20131 }
20132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20133 return resultobj;
20134 fail:
20135 return NULL;
20136 }
20137
20138
20139 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20140 PyObject *resultobj = 0;
20141 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20142 void *argp1 = 0 ;
20143 int res1 = 0 ;
20144 PyObject *swig_obj[1] ;
20145
20146 if (!args) SWIG_fail;
20147 swig_obj[0] = args;
20148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20149 if (!SWIG_IsOK(res1)) {
20150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20151 }
20152 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20153 {
20154 PyThreadState* __tstate = wxPyBeginAllowThreads();
20155 (arg1)->Veto();
20156 wxPyEndAllowThreads(__tstate);
20157 if (PyErr_Occurred()) SWIG_fail;
20158 }
20159 resultobj = SWIG_Py_Void();
20160 return resultobj;
20161 fail:
20162 return NULL;
20163 }
20164
20165
20166 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20167 PyObject *resultobj = 0;
20168 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20169 void *argp1 = 0 ;
20170 int res1 = 0 ;
20171 PyObject *swig_obj[1] ;
20172
20173 if (!args) SWIG_fail;
20174 swig_obj[0] = args;
20175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20176 if (!SWIG_IsOK(res1)) {
20177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20178 }
20179 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20180 {
20181 PyThreadState* __tstate = wxPyBeginAllowThreads();
20182 (arg1)->Allow();
20183 wxPyEndAllowThreads(__tstate);
20184 if (PyErr_Occurred()) SWIG_fail;
20185 }
20186 resultobj = SWIG_Py_Void();
20187 return resultobj;
20188 fail:
20189 return NULL;
20190 }
20191
20192
20193 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20194 PyObject *resultobj = 0;
20195 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20196 bool result;
20197 void *argp1 = 0 ;
20198 int res1 = 0 ;
20199 PyObject *swig_obj[1] ;
20200
20201 if (!args) SWIG_fail;
20202 swig_obj[0] = args;
20203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20204 if (!SWIG_IsOK(res1)) {
20205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20206 }
20207 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20208 {
20209 PyThreadState* __tstate = wxPyBeginAllowThreads();
20210 result = (bool)(arg1)->IsAllowed();
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 {
20215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20216 }
20217 return resultobj;
20218 fail:
20219 return NULL;
20220 }
20221
20222
20223 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20224 PyObject *obj;
20225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20226 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20227 return SWIG_Py_Void();
20228 }
20229
20230 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20231 return SWIG_Python_InitShadowInstance(args);
20232 }
20233
20234 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20235 PyObject *resultobj = 0;
20236 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20237 int arg2 = (int) 0 ;
20238 int arg3 = (int) 0 ;
20239 int arg4 = (int) 0 ;
20240 wxScrollEvent *result = 0 ;
20241 int val1 ;
20242 int ecode1 = 0 ;
20243 int val2 ;
20244 int ecode2 = 0 ;
20245 int val3 ;
20246 int ecode3 = 0 ;
20247 int val4 ;
20248 int ecode4 = 0 ;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 PyObject * obj2 = 0 ;
20252 PyObject * obj3 = 0 ;
20253 char * kwnames[] = {
20254 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20255 };
20256
20257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20258 if (obj0) {
20259 ecode1 = SWIG_AsVal_int(obj0, &val1);
20260 if (!SWIG_IsOK(ecode1)) {
20261 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20262 }
20263 arg1 = static_cast< wxEventType >(val1);
20264 }
20265 if (obj1) {
20266 ecode2 = SWIG_AsVal_int(obj1, &val2);
20267 if (!SWIG_IsOK(ecode2)) {
20268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20269 }
20270 arg2 = static_cast< int >(val2);
20271 }
20272 if (obj2) {
20273 ecode3 = SWIG_AsVal_int(obj2, &val3);
20274 if (!SWIG_IsOK(ecode3)) {
20275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20276 }
20277 arg3 = static_cast< int >(val3);
20278 }
20279 if (obj3) {
20280 ecode4 = SWIG_AsVal_int(obj3, &val4);
20281 if (!SWIG_IsOK(ecode4)) {
20282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20283 }
20284 arg4 = static_cast< int >(val4);
20285 }
20286 {
20287 PyThreadState* __tstate = wxPyBeginAllowThreads();
20288 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20302 int result;
20303 void *argp1 = 0 ;
20304 int res1 = 0 ;
20305 PyObject *swig_obj[1] ;
20306
20307 if (!args) SWIG_fail;
20308 swig_obj[0] = args;
20309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20310 if (!SWIG_IsOK(res1)) {
20311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20312 }
20313 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 resultobj = SWIG_From_int(static_cast< int >(result));
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *resultobj = 0;
20329 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20330 int result;
20331 void *argp1 = 0 ;
20332 int res1 = 0 ;
20333 PyObject *swig_obj[1] ;
20334
20335 if (!args) SWIG_fail;
20336 swig_obj[0] = args;
20337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20338 if (!SWIG_IsOK(res1)) {
20339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20340 }
20341 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20342 {
20343 PyThreadState* __tstate = wxPyBeginAllowThreads();
20344 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 resultobj = SWIG_From_int(static_cast< int >(result));
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20356 PyObject *resultobj = 0;
20357 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20358 int arg2 ;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 int val2 ;
20362 int ecode2 = 0 ;
20363 PyObject * obj0 = 0 ;
20364 PyObject * obj1 = 0 ;
20365 char * kwnames[] = {
20366 (char *) "self",(char *) "orient", NULL
20367 };
20368
20369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20371 if (!SWIG_IsOK(res1)) {
20372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20373 }
20374 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20375 ecode2 = SWIG_AsVal_int(obj1, &val2);
20376 if (!SWIG_IsOK(ecode2)) {
20377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20378 }
20379 arg2 = static_cast< int >(val2);
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 (arg1)->SetOrientation(arg2);
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 resultobj = SWIG_Py_Void();
20387 return resultobj;
20388 fail:
20389 return NULL;
20390 }
20391
20392
20393 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20394 PyObject *resultobj = 0;
20395 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20396 int arg2 ;
20397 void *argp1 = 0 ;
20398 int res1 = 0 ;
20399 int val2 ;
20400 int ecode2 = 0 ;
20401 PyObject * obj0 = 0 ;
20402 PyObject * obj1 = 0 ;
20403 char * kwnames[] = {
20404 (char *) "self",(char *) "pos", NULL
20405 };
20406
20407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20409 if (!SWIG_IsOK(res1)) {
20410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20411 }
20412 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20413 ecode2 = SWIG_AsVal_int(obj1, &val2);
20414 if (!SWIG_IsOK(ecode2)) {
20415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20416 }
20417 arg2 = static_cast< int >(val2);
20418 {
20419 PyThreadState* __tstate = wxPyBeginAllowThreads();
20420 (arg1)->SetPosition(arg2);
20421 wxPyEndAllowThreads(__tstate);
20422 if (PyErr_Occurred()) SWIG_fail;
20423 }
20424 resultobj = SWIG_Py_Void();
20425 return resultobj;
20426 fail:
20427 return NULL;
20428 }
20429
20430
20431 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *obj;
20433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20434 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20435 return SWIG_Py_Void();
20436 }
20437
20438 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20439 return SWIG_Python_InitShadowInstance(args);
20440 }
20441
20442 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20443 PyObject *resultobj = 0;
20444 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20445 int arg2 = (int) 0 ;
20446 int arg3 = (int) 0 ;
20447 wxScrollWinEvent *result = 0 ;
20448 int val1 ;
20449 int ecode1 = 0 ;
20450 int val2 ;
20451 int ecode2 = 0 ;
20452 int val3 ;
20453 int ecode3 = 0 ;
20454 PyObject * obj0 = 0 ;
20455 PyObject * obj1 = 0 ;
20456 PyObject * obj2 = 0 ;
20457 char * kwnames[] = {
20458 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20459 };
20460
20461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20462 if (obj0) {
20463 ecode1 = SWIG_AsVal_int(obj0, &val1);
20464 if (!SWIG_IsOK(ecode1)) {
20465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20466 }
20467 arg1 = static_cast< wxEventType >(val1);
20468 }
20469 if (obj1) {
20470 ecode2 = SWIG_AsVal_int(obj1, &val2);
20471 if (!SWIG_IsOK(ecode2)) {
20472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20473 }
20474 arg2 = static_cast< int >(val2);
20475 }
20476 if (obj2) {
20477 ecode3 = SWIG_AsVal_int(obj2, &val3);
20478 if (!SWIG_IsOK(ecode3)) {
20479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20480 }
20481 arg3 = static_cast< int >(val3);
20482 }
20483 {
20484 PyThreadState* __tstate = wxPyBeginAllowThreads();
20485 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20497 PyObject *resultobj = 0;
20498 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20499 int result;
20500 void *argp1 = 0 ;
20501 int res1 = 0 ;
20502 PyObject *swig_obj[1] ;
20503
20504 if (!args) SWIG_fail;
20505 swig_obj[0] = args;
20506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20507 if (!SWIG_IsOK(res1)) {
20508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20509 }
20510 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20511 {
20512 PyThreadState* __tstate = wxPyBeginAllowThreads();
20513 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_From_int(static_cast< int >(result));
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20525 PyObject *resultobj = 0;
20526 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20527 int result;
20528 void *argp1 = 0 ;
20529 int res1 = 0 ;
20530 PyObject *swig_obj[1] ;
20531
20532 if (!args) SWIG_fail;
20533 swig_obj[0] = args;
20534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20535 if (!SWIG_IsOK(res1)) {
20536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20537 }
20538 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20539 {
20540 PyThreadState* __tstate = wxPyBeginAllowThreads();
20541 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 resultobj = SWIG_From_int(static_cast< int >(result));
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20553 PyObject *resultobj = 0;
20554 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20555 int arg2 ;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 int val2 ;
20559 int ecode2 = 0 ;
20560 PyObject * obj0 = 0 ;
20561 PyObject * obj1 = 0 ;
20562 char * kwnames[] = {
20563 (char *) "self",(char *) "orient", NULL
20564 };
20565
20566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20568 if (!SWIG_IsOK(res1)) {
20569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20570 }
20571 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20572 ecode2 = SWIG_AsVal_int(obj1, &val2);
20573 if (!SWIG_IsOK(ecode2)) {
20574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20575 }
20576 arg2 = static_cast< int >(val2);
20577 {
20578 PyThreadState* __tstate = wxPyBeginAllowThreads();
20579 (arg1)->SetOrientation(arg2);
20580 wxPyEndAllowThreads(__tstate);
20581 if (PyErr_Occurred()) SWIG_fail;
20582 }
20583 resultobj = SWIG_Py_Void();
20584 return resultobj;
20585 fail:
20586 return NULL;
20587 }
20588
20589
20590 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20591 PyObject *resultobj = 0;
20592 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20593 int arg2 ;
20594 void *argp1 = 0 ;
20595 int res1 = 0 ;
20596 int val2 ;
20597 int ecode2 = 0 ;
20598 PyObject * obj0 = 0 ;
20599 PyObject * obj1 = 0 ;
20600 char * kwnames[] = {
20601 (char *) "self",(char *) "pos", NULL
20602 };
20603
20604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20608 }
20609 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20610 ecode2 = SWIG_AsVal_int(obj1, &val2);
20611 if (!SWIG_IsOK(ecode2)) {
20612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20613 }
20614 arg2 = static_cast< int >(val2);
20615 {
20616 PyThreadState* __tstate = wxPyBeginAllowThreads();
20617 (arg1)->SetPosition(arg2);
20618 wxPyEndAllowThreads(__tstate);
20619 if (PyErr_Occurred()) SWIG_fail;
20620 }
20621 resultobj = SWIG_Py_Void();
20622 return resultobj;
20623 fail:
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20629 PyObject *obj;
20630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20631 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20632 return SWIG_Py_Void();
20633 }
20634
20635 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20636 return SWIG_Python_InitShadowInstance(args);
20637 }
20638
20639 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj = 0;
20641 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20642 wxMouseEvent *result = 0 ;
20643 int val1 ;
20644 int ecode1 = 0 ;
20645 PyObject * obj0 = 0 ;
20646 char * kwnames[] = {
20647 (char *) "mouseType", NULL
20648 };
20649
20650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20651 if (obj0) {
20652 ecode1 = SWIG_AsVal_int(obj0, &val1);
20653 if (!SWIG_IsOK(ecode1)) {
20654 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20655 }
20656 arg1 = static_cast< wxEventType >(val1);
20657 }
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 {
20665 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20666 }
20667 return resultobj;
20668 fail:
20669 return NULL;
20670 }
20671
20672
20673 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20674 PyObject *resultobj = 0;
20675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20676 bool result;
20677 void *argp1 = 0 ;
20678 int res1 = 0 ;
20679 PyObject *swig_obj[1] ;
20680
20681 if (!args) SWIG_fail;
20682 swig_obj[0] = args;
20683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20684 if (!SWIG_IsOK(res1)) {
20685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20686 }
20687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20688 {
20689 PyThreadState* __tstate = wxPyBeginAllowThreads();
20690 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 {
20695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20696 }
20697 return resultobj;
20698 fail:
20699 return NULL;
20700 }
20701
20702
20703 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20704 PyObject *resultobj = 0;
20705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20706 int arg2 = (int) wxMOUSE_BTN_ANY ;
20707 bool result;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 int val2 ;
20711 int ecode2 = 0 ;
20712 PyObject * obj0 = 0 ;
20713 PyObject * obj1 = 0 ;
20714 char * kwnames[] = {
20715 (char *) "self",(char *) "but", NULL
20716 };
20717
20718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20720 if (!SWIG_IsOK(res1)) {
20721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20722 }
20723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20724 if (obj1) {
20725 ecode2 = SWIG_AsVal_int(obj1, &val2);
20726 if (!SWIG_IsOK(ecode2)) {
20727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20728 }
20729 arg2 = static_cast< int >(val2);
20730 }
20731 {
20732 PyThreadState* __tstate = wxPyBeginAllowThreads();
20733 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20734 wxPyEndAllowThreads(__tstate);
20735 if (PyErr_Occurred()) SWIG_fail;
20736 }
20737 {
20738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20739 }
20740 return resultobj;
20741 fail:
20742 return NULL;
20743 }
20744
20745
20746 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20747 PyObject *resultobj = 0;
20748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20749 int arg2 = (int) wxMOUSE_BTN_ANY ;
20750 bool result;
20751 void *argp1 = 0 ;
20752 int res1 = 0 ;
20753 int val2 ;
20754 int ecode2 = 0 ;
20755 PyObject * obj0 = 0 ;
20756 PyObject * obj1 = 0 ;
20757 char * kwnames[] = {
20758 (char *) "self",(char *) "but", NULL
20759 };
20760
20761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20763 if (!SWIG_IsOK(res1)) {
20764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20765 }
20766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20767 if (obj1) {
20768 ecode2 = SWIG_AsVal_int(obj1, &val2);
20769 if (!SWIG_IsOK(ecode2)) {
20770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20771 }
20772 arg2 = static_cast< int >(val2);
20773 }
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20777 wxPyEndAllowThreads(__tstate);
20778 if (PyErr_Occurred()) SWIG_fail;
20779 }
20780 {
20781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20782 }
20783 return resultobj;
20784 fail:
20785 return NULL;
20786 }
20787
20788
20789 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20790 PyObject *resultobj = 0;
20791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20792 int arg2 = (int) wxMOUSE_BTN_ANY ;
20793 bool result;
20794 void *argp1 = 0 ;
20795 int res1 = 0 ;
20796 int val2 ;
20797 int ecode2 = 0 ;
20798 PyObject * obj0 = 0 ;
20799 PyObject * obj1 = 0 ;
20800 char * kwnames[] = {
20801 (char *) "self",(char *) "but", NULL
20802 };
20803
20804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20806 if (!SWIG_IsOK(res1)) {
20807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20808 }
20809 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20810 if (obj1) {
20811 ecode2 = SWIG_AsVal_int(obj1, &val2);
20812 if (!SWIG_IsOK(ecode2)) {
20813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20814 }
20815 arg2 = static_cast< int >(val2);
20816 }
20817 {
20818 PyThreadState* __tstate = wxPyBeginAllowThreads();
20819 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20820 wxPyEndAllowThreads(__tstate);
20821 if (PyErr_Occurred()) SWIG_fail;
20822 }
20823 {
20824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20825 }
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20833 PyObject *resultobj = 0;
20834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20835 int arg2 ;
20836 bool result;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 int val2 ;
20840 int ecode2 = 0 ;
20841 PyObject * obj0 = 0 ;
20842 PyObject * obj1 = 0 ;
20843 char * kwnames[] = {
20844 (char *) "self",(char *) "button", NULL
20845 };
20846
20847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20849 if (!SWIG_IsOK(res1)) {
20850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20851 }
20852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20853 ecode2 = SWIG_AsVal_int(obj1, &val2);
20854 if (!SWIG_IsOK(ecode2)) {
20855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20856 }
20857 arg2 = static_cast< int >(val2);
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 {
20865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20866 }
20867 return resultobj;
20868 fail:
20869 return NULL;
20870 }
20871
20872
20873 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20874 PyObject *resultobj = 0;
20875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20876 int arg2 ;
20877 bool result;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 int val2 ;
20881 int ecode2 = 0 ;
20882 PyObject * obj0 = 0 ;
20883 PyObject * obj1 = 0 ;
20884 char * kwnames[] = {
20885 (char *) "self",(char *) "but", NULL
20886 };
20887
20888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20890 if (!SWIG_IsOK(res1)) {
20891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20892 }
20893 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20894 ecode2 = SWIG_AsVal_int(obj1, &val2);
20895 if (!SWIG_IsOK(ecode2)) {
20896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20897 }
20898 arg2 = static_cast< int >(val2);
20899 {
20900 PyThreadState* __tstate = wxPyBeginAllowThreads();
20901 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20902 wxPyEndAllowThreads(__tstate);
20903 if (PyErr_Occurred()) SWIG_fail;
20904 }
20905 {
20906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20915 PyObject *resultobj = 0;
20916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20917 int result;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20927 }
20928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_From_int(static_cast< int >(result));
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20945 bool result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20955 }
20956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 {
20964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20965 }
20966 return resultobj;
20967 fail:
20968 return NULL;
20969 }
20970
20971
20972 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20973 PyObject *resultobj = 0;
20974 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20975 bool result;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 PyObject *swig_obj[1] ;
20979
20980 if (!args) SWIG_fail;
20981 swig_obj[0] = args;
20982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20985 }
20986 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21003 PyObject *resultobj = 0;
21004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21005 bool result;
21006 void *argp1 = 0 ;
21007 int res1 = 0 ;
21008 PyObject *swig_obj[1] ;
21009
21010 if (!args) SWIG_fail;
21011 swig_obj[0] = args;
21012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21015 }
21016 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 {
21024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21025 }
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21035 bool result;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 PyObject *swig_obj[1] ;
21039
21040 if (!args) SWIG_fail;
21041 swig_obj[0] = args;
21042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21043 if (!SWIG_IsOK(res1)) {
21044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21045 }
21046 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21047 {
21048 PyThreadState* __tstate = wxPyBeginAllowThreads();
21049 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21050 wxPyEndAllowThreads(__tstate);
21051 if (PyErr_Occurred()) SWIG_fail;
21052 }
21053 {
21054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21055 }
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21065 bool result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 PyObject *swig_obj[1] ;
21069
21070 if (!args) SWIG_fail;
21071 swig_obj[0] = args;
21072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21075 }
21076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21080 wxPyEndAllowThreads(__tstate);
21081 if (PyErr_Occurred()) SWIG_fail;
21082 }
21083 {
21084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21085 }
21086 return resultobj;
21087 fail:
21088 return NULL;
21089 }
21090
21091
21092 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21093 PyObject *resultobj = 0;
21094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21095 bool result;
21096 void *argp1 = 0 ;
21097 int res1 = 0 ;
21098 PyObject *swig_obj[1] ;
21099
21100 if (!args) SWIG_fail;
21101 swig_obj[0] = args;
21102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21105 }
21106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21107 {
21108 PyThreadState* __tstate = wxPyBeginAllowThreads();
21109 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21110 wxPyEndAllowThreads(__tstate);
21111 if (PyErr_Occurred()) SWIG_fail;
21112 }
21113 {
21114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21115 }
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *resultobj = 0;
21124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21125 bool result;
21126 void *argp1 = 0 ;
21127 int res1 = 0 ;
21128 PyObject *swig_obj[1] ;
21129
21130 if (!args) SWIG_fail;
21131 swig_obj[0] = args;
21132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21133 if (!SWIG_IsOK(res1)) {
21134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21135 }
21136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21137 {
21138 PyThreadState* __tstate = wxPyBeginAllowThreads();
21139 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21140 wxPyEndAllowThreads(__tstate);
21141 if (PyErr_Occurred()) SWIG_fail;
21142 }
21143 {
21144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21145 }
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *resultobj = 0;
21154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21155 bool result;
21156 void *argp1 = 0 ;
21157 int res1 = 0 ;
21158 PyObject *swig_obj[1] ;
21159
21160 if (!args) SWIG_fail;
21161 swig_obj[0] = args;
21162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21163 if (!SWIG_IsOK(res1)) {
21164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21165 }
21166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21167 {
21168 PyThreadState* __tstate = wxPyBeginAllowThreads();
21169 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21170 wxPyEndAllowThreads(__tstate);
21171 if (PyErr_Occurred()) SWIG_fail;
21172 }
21173 {
21174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21175 }
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21185 bool result;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 PyObject *swig_obj[1] ;
21189
21190 if (!args) SWIG_fail;
21191 swig_obj[0] = args;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21195 }
21196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 {
21204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 bool result;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 PyObject *swig_obj[1] ;
21219
21220 if (!args) SWIG_fail;
21221 swig_obj[0] = args;
21222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21223 if (!SWIG_IsOK(res1)) {
21224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21225 }
21226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21227 {
21228 PyThreadState* __tstate = wxPyBeginAllowThreads();
21229 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 {
21234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21235 }
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21245 bool result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21265 }
21266 return resultobj;
21267 fail:
21268 return NULL;
21269 }
21270
21271
21272 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21273 PyObject *resultobj = 0;
21274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21275 bool result;
21276 void *argp1 = 0 ;
21277 int res1 = 0 ;
21278 PyObject *swig_obj[1] ;
21279
21280 if (!args) SWIG_fail;
21281 swig_obj[0] = args;
21282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21283 if (!SWIG_IsOK(res1)) {
21284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21285 }
21286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21287 {
21288 PyThreadState* __tstate = wxPyBeginAllowThreads();
21289 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21290 wxPyEndAllowThreads(__tstate);
21291 if (PyErr_Occurred()) SWIG_fail;
21292 }
21293 {
21294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21295 }
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21303 PyObject *resultobj = 0;
21304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21305 bool result;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 PyObject *swig_obj[1] ;
21309
21310 if (!args) SWIG_fail;
21311 swig_obj[0] = args;
21312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21313 if (!SWIG_IsOK(res1)) {
21314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21315 }
21316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21317 {
21318 PyThreadState* __tstate = wxPyBeginAllowThreads();
21319 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21320 wxPyEndAllowThreads(__tstate);
21321 if (PyErr_Occurred()) SWIG_fail;
21322 }
21323 {
21324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21325 }
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21333 PyObject *resultobj = 0;
21334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21335 bool result;
21336 void *argp1 = 0 ;
21337 int res1 = 0 ;
21338 PyObject *swig_obj[1] ;
21339
21340 if (!args) SWIG_fail;
21341 swig_obj[0] = args;
21342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21343 if (!SWIG_IsOK(res1)) {
21344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21345 }
21346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21350 wxPyEndAllowThreads(__tstate);
21351 if (PyErr_Occurred()) SWIG_fail;
21352 }
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21363 PyObject *resultobj = 0;
21364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21365 bool result;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 PyObject *swig_obj[1] ;
21369
21370 if (!args) SWIG_fail;
21371 swig_obj[0] = args;
21372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21373 if (!SWIG_IsOK(res1)) {
21374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21375 }
21376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21377 {
21378 PyThreadState* __tstate = wxPyBeginAllowThreads();
21379 result = (bool)(arg1)->LeftIsDown();
21380 wxPyEndAllowThreads(__tstate);
21381 if (PyErr_Occurred()) SWIG_fail;
21382 }
21383 {
21384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21385 }
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21393 PyObject *resultobj = 0;
21394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21395 bool result;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 PyObject *swig_obj[1] ;
21399
21400 if (!args) SWIG_fail;
21401 swig_obj[0] = args;
21402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21403 if (!SWIG_IsOK(res1)) {
21404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21405 }
21406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21407 {
21408 PyThreadState* __tstate = wxPyBeginAllowThreads();
21409 result = (bool)(arg1)->MiddleIsDown();
21410 wxPyEndAllowThreads(__tstate);
21411 if (PyErr_Occurred()) SWIG_fail;
21412 }
21413 {
21414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21415 }
21416 return resultobj;
21417 fail:
21418 return NULL;
21419 }
21420
21421
21422 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21423 PyObject *resultobj = 0;
21424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21425 bool result;
21426 void *argp1 = 0 ;
21427 int res1 = 0 ;
21428 PyObject *swig_obj[1] ;
21429
21430 if (!args) SWIG_fail;
21431 swig_obj[0] = args;
21432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21433 if (!SWIG_IsOK(res1)) {
21434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21435 }
21436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21437 {
21438 PyThreadState* __tstate = wxPyBeginAllowThreads();
21439 result = (bool)(arg1)->RightIsDown();
21440 wxPyEndAllowThreads(__tstate);
21441 if (PyErr_Occurred()) SWIG_fail;
21442 }
21443 {
21444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21445 }
21446 return resultobj;
21447 fail:
21448 return NULL;
21449 }
21450
21451
21452 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21453 PyObject *resultobj = 0;
21454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21455 bool result;
21456 void *argp1 = 0 ;
21457 int res1 = 0 ;
21458 PyObject *swig_obj[1] ;
21459
21460 if (!args) SWIG_fail;
21461 swig_obj[0] = args;
21462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21463 if (!SWIG_IsOK(res1)) {
21464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21465 }
21466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21467 {
21468 PyThreadState* __tstate = wxPyBeginAllowThreads();
21469 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21470 wxPyEndAllowThreads(__tstate);
21471 if (PyErr_Occurred()) SWIG_fail;
21472 }
21473 {
21474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21475 }
21476 return resultobj;
21477 fail:
21478 return NULL;
21479 }
21480
21481
21482 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21483 PyObject *resultobj = 0;
21484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21485 bool result;
21486 void *argp1 = 0 ;
21487 int res1 = 0 ;
21488 PyObject *swig_obj[1] ;
21489
21490 if (!args) SWIG_fail;
21491 swig_obj[0] = args;
21492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21495 }
21496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21497 {
21498 PyThreadState* __tstate = wxPyBeginAllowThreads();
21499 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21500 wxPyEndAllowThreads(__tstate);
21501 if (PyErr_Occurred()) SWIG_fail;
21502 }
21503 {
21504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21505 }
21506 return resultobj;
21507 fail:
21508 return NULL;
21509 }
21510
21511
21512 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21513 PyObject *resultobj = 0;
21514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21515 bool result;
21516 void *argp1 = 0 ;
21517 int res1 = 0 ;
21518 PyObject *swig_obj[1] ;
21519
21520 if (!args) SWIG_fail;
21521 swig_obj[0] = args;
21522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21523 if (!SWIG_IsOK(res1)) {
21524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21525 }
21526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21527 {
21528 PyThreadState* __tstate = wxPyBeginAllowThreads();
21529 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21530 wxPyEndAllowThreads(__tstate);
21531 if (PyErr_Occurred()) SWIG_fail;
21532 }
21533 {
21534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21535 }
21536 return resultobj;
21537 fail:
21538 return NULL;
21539 }
21540
21541
21542 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21543 PyObject *resultobj = 0;
21544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21545 bool result;
21546 void *argp1 = 0 ;
21547 int res1 = 0 ;
21548 PyObject *swig_obj[1] ;
21549
21550 if (!args) SWIG_fail;
21551 swig_obj[0] = args;
21552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21553 if (!SWIG_IsOK(res1)) {
21554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21555 }
21556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21557 {
21558 PyThreadState* __tstate = wxPyBeginAllowThreads();
21559 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 {
21564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21565 }
21566 return resultobj;
21567 fail:
21568 return NULL;
21569 }
21570
21571
21572 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21573 PyObject *resultobj = 0;
21574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21575 wxPoint result;
21576 void *argp1 = 0 ;
21577 int res1 = 0 ;
21578 PyObject *swig_obj[1] ;
21579
21580 if (!args) SWIG_fail;
21581 swig_obj[0] = args;
21582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21583 if (!SWIG_IsOK(res1)) {
21584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21585 }
21586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21587 {
21588 PyThreadState* __tstate = wxPyBeginAllowThreads();
21589 result = (arg1)->GetPosition();
21590 wxPyEndAllowThreads(__tstate);
21591 if (PyErr_Occurred()) SWIG_fail;
21592 }
21593 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21594 return resultobj;
21595 fail:
21596 return NULL;
21597 }
21598
21599
21600 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21601 PyObject *resultobj = 0;
21602 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21603 long *arg2 = (long *) 0 ;
21604 long *arg3 = (long *) 0 ;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 long temp2 ;
21608 int res2 = SWIG_TMPOBJ ;
21609 long temp3 ;
21610 int res3 = SWIG_TMPOBJ ;
21611 PyObject *swig_obj[1] ;
21612
21613 arg2 = &temp2;
21614 arg3 = &temp3;
21615 if (!args) SWIG_fail;
21616 swig_obj[0] = args;
21617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 (arg1)->GetPosition(arg2,arg3);
21625 wxPyEndAllowThreads(__tstate);
21626 if (PyErr_Occurred()) SWIG_fail;
21627 }
21628 resultobj = SWIG_Py_Void();
21629 if (SWIG_IsTmpObj(res2)) {
21630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21631 } else {
21632 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21634 }
21635 if (SWIG_IsTmpObj(res3)) {
21636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21637 } else {
21638 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21639 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21640 }
21641 return resultobj;
21642 fail:
21643 return NULL;
21644 }
21645
21646
21647 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21648 PyObject *resultobj = 0;
21649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21650 wxDC *arg2 = 0 ;
21651 wxPoint result;
21652 void *argp1 = 0 ;
21653 int res1 = 0 ;
21654 void *argp2 = 0 ;
21655 int res2 = 0 ;
21656 PyObject * obj0 = 0 ;
21657 PyObject * obj1 = 0 ;
21658 char * kwnames[] = {
21659 (char *) "self",(char *) "dc", NULL
21660 };
21661
21662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21664 if (!SWIG_IsOK(res1)) {
21665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21666 }
21667 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21668 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21669 if (!SWIG_IsOK(res2)) {
21670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21671 }
21672 if (!argp2) {
21673 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21674 }
21675 arg2 = reinterpret_cast< wxDC * >(argp2);
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21679 wxPyEndAllowThreads(__tstate);
21680 if (PyErr_Occurred()) SWIG_fail;
21681 }
21682 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21692 int result;
21693 void *argp1 = 0 ;
21694 int res1 = 0 ;
21695 PyObject *swig_obj[1] ;
21696
21697 if (!args) SWIG_fail;
21698 swig_obj[0] = args;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 {
21705 PyThreadState* __tstate = wxPyBeginAllowThreads();
21706 result = (int)((wxMouseEvent const *)arg1)->GetX();
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 resultobj = SWIG_From_int(static_cast< int >(result));
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21718 PyObject *resultobj = 0;
21719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21720 int result;
21721 void *argp1 = 0 ;
21722 int res1 = 0 ;
21723 PyObject *swig_obj[1] ;
21724
21725 if (!args) SWIG_fail;
21726 swig_obj[0] = args;
21727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21728 if (!SWIG_IsOK(res1)) {
21729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21730 }
21731 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (int)((wxMouseEvent const *)arg1)->GetY();
21735 wxPyEndAllowThreads(__tstate);
21736 if (PyErr_Occurred()) SWIG_fail;
21737 }
21738 resultobj = SWIG_From_int(static_cast< int >(result));
21739 return resultobj;
21740 fail:
21741 return NULL;
21742 }
21743
21744
21745 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21746 PyObject *resultobj = 0;
21747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21748 int result;
21749 void *argp1 = 0 ;
21750 int res1 = 0 ;
21751 PyObject *swig_obj[1] ;
21752
21753 if (!args) SWIG_fail;
21754 swig_obj[0] = args;
21755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21756 if (!SWIG_IsOK(res1)) {
21757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21758 }
21759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21760 {
21761 PyThreadState* __tstate = wxPyBeginAllowThreads();
21762 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21763 wxPyEndAllowThreads(__tstate);
21764 if (PyErr_Occurred()) SWIG_fail;
21765 }
21766 resultobj = SWIG_From_int(static_cast< int >(result));
21767 return resultobj;
21768 fail:
21769 return NULL;
21770 }
21771
21772
21773 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21774 PyObject *resultobj = 0;
21775 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21776 int result;
21777 void *argp1 = 0 ;
21778 int res1 = 0 ;
21779 PyObject *swig_obj[1] ;
21780
21781 if (!args) SWIG_fail;
21782 swig_obj[0] = args;
21783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21784 if (!SWIG_IsOK(res1)) {
21785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21786 }
21787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21788 {
21789 PyThreadState* __tstate = wxPyBeginAllowThreads();
21790 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21791 wxPyEndAllowThreads(__tstate);
21792 if (PyErr_Occurred()) SWIG_fail;
21793 }
21794 resultobj = SWIG_From_int(static_cast< int >(result));
21795 return resultobj;
21796 fail:
21797 return NULL;
21798 }
21799
21800
21801 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21802 PyObject *resultobj = 0;
21803 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21804 int result;
21805 void *argp1 = 0 ;
21806 int res1 = 0 ;
21807 PyObject *swig_obj[1] ;
21808
21809 if (!args) SWIG_fail;
21810 swig_obj[0] = args;
21811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21812 if (!SWIG_IsOK(res1)) {
21813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21814 }
21815 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21816 {
21817 PyThreadState* __tstate = wxPyBeginAllowThreads();
21818 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 resultobj = SWIG_From_int(static_cast< int >(result));
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21830 PyObject *resultobj = 0;
21831 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21832 bool result;
21833 void *argp1 = 0 ;
21834 int res1 = 0 ;
21835 PyObject *swig_obj[1] ;
21836
21837 if (!args) SWIG_fail;
21838 swig_obj[0] = args;
21839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21840 if (!SWIG_IsOK(res1)) {
21841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21842 }
21843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21847 wxPyEndAllowThreads(__tstate);
21848 if (PyErr_Occurred()) SWIG_fail;
21849 }
21850 {
21851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21852 }
21853 return resultobj;
21854 fail:
21855 return NULL;
21856 }
21857
21858
21859 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21860 PyObject *resultobj = 0;
21861 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21862 int arg2 ;
21863 void *argp1 = 0 ;
21864 int res1 = 0 ;
21865 int val2 ;
21866 int ecode2 = 0 ;
21867 PyObject *swig_obj[2] ;
21868
21869 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21871 if (!SWIG_IsOK(res1)) {
21872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21873 }
21874 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21875 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21876 if (!SWIG_IsOK(ecode2)) {
21877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21878 }
21879 arg2 = static_cast< int >(val2);
21880 if (arg1) (arg1)->m_x = arg2;
21881
21882 resultobj = SWIG_Py_Void();
21883 return resultobj;
21884 fail:
21885 return NULL;
21886 }
21887
21888
21889 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21890 PyObject *resultobj = 0;
21891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21892 int result;
21893 void *argp1 = 0 ;
21894 int res1 = 0 ;
21895 PyObject *swig_obj[1] ;
21896
21897 if (!args) SWIG_fail;
21898 swig_obj[0] = args;
21899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21900 if (!SWIG_IsOK(res1)) {
21901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21902 }
21903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21904 result = (int) ((arg1)->m_x);
21905 resultobj = SWIG_From_int(static_cast< int >(result));
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 PyObject *resultobj = 0;
21914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21915 int arg2 ;
21916 void *argp1 = 0 ;
21917 int res1 = 0 ;
21918 int val2 ;
21919 int ecode2 = 0 ;
21920 PyObject *swig_obj[2] ;
21921
21922 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21924 if (!SWIG_IsOK(res1)) {
21925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21926 }
21927 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21928 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21929 if (!SWIG_IsOK(ecode2)) {
21930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21931 }
21932 arg2 = static_cast< int >(val2);
21933 if (arg1) (arg1)->m_y = arg2;
21934
21935 resultobj = SWIG_Py_Void();
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 PyObject *resultobj = 0;
21944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21945 int result;
21946 void *argp1 = 0 ;
21947 int res1 = 0 ;
21948 PyObject *swig_obj[1] ;
21949
21950 if (!args) SWIG_fail;
21951 swig_obj[0] = args;
21952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21955 }
21956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21957 result = (int) ((arg1)->m_y);
21958 resultobj = SWIG_From_int(static_cast< int >(result));
21959 return resultobj;
21960 fail:
21961 return NULL;
21962 }
21963
21964
21965 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21966 PyObject *resultobj = 0;
21967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21968 bool arg2 ;
21969 void *argp1 = 0 ;
21970 int res1 = 0 ;
21971 bool val2 ;
21972 int ecode2 = 0 ;
21973 PyObject *swig_obj[2] ;
21974
21975 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21977 if (!SWIG_IsOK(res1)) {
21978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21979 }
21980 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21981 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21982 if (!SWIG_IsOK(ecode2)) {
21983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21984 }
21985 arg2 = static_cast< bool >(val2);
21986 if (arg1) (arg1)->m_leftDown = arg2;
21987
21988 resultobj = SWIG_Py_Void();
21989 return resultobj;
21990 fail:
21991 return NULL;
21992 }
21993
21994
21995 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21996 PyObject *resultobj = 0;
21997 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21998 bool result;
21999 void *argp1 = 0 ;
22000 int res1 = 0 ;
22001 PyObject *swig_obj[1] ;
22002
22003 if (!args) SWIG_fail;
22004 swig_obj[0] = args;
22005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22006 if (!SWIG_IsOK(res1)) {
22007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22008 }
22009 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22010 result = (bool) ((arg1)->m_leftDown);
22011 {
22012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22013 }
22014 return resultobj;
22015 fail:
22016 return NULL;
22017 }
22018
22019
22020 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22021 PyObject *resultobj = 0;
22022 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22023 bool arg2 ;
22024 void *argp1 = 0 ;
22025 int res1 = 0 ;
22026 bool val2 ;
22027 int ecode2 = 0 ;
22028 PyObject *swig_obj[2] ;
22029
22030 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22032 if (!SWIG_IsOK(res1)) {
22033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22034 }
22035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22036 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22037 if (!SWIG_IsOK(ecode2)) {
22038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22039 }
22040 arg2 = static_cast< bool >(val2);
22041 if (arg1) (arg1)->m_middleDown = arg2;
22042
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22053 bool result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22063 }
22064 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22065 result = (bool) ((arg1)->m_middleDown);
22066 {
22067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22068 }
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22076 PyObject *resultobj = 0;
22077 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22078 bool arg2 ;
22079 void *argp1 = 0 ;
22080 int res1 = 0 ;
22081 bool val2 ;
22082 int ecode2 = 0 ;
22083 PyObject *swig_obj[2] ;
22084
22085 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22087 if (!SWIG_IsOK(res1)) {
22088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22089 }
22090 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22091 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22092 if (!SWIG_IsOK(ecode2)) {
22093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22094 }
22095 arg2 = static_cast< bool >(val2);
22096 if (arg1) (arg1)->m_rightDown = arg2;
22097
22098 resultobj = SWIG_Py_Void();
22099 return resultobj;
22100 fail:
22101 return NULL;
22102 }
22103
22104
22105 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22106 PyObject *resultobj = 0;
22107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22108 bool result;
22109 void *argp1 = 0 ;
22110 int res1 = 0 ;
22111 PyObject *swig_obj[1] ;
22112
22113 if (!args) SWIG_fail;
22114 swig_obj[0] = args;
22115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22116 if (!SWIG_IsOK(res1)) {
22117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22118 }
22119 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22120 result = (bool) ((arg1)->m_rightDown);
22121 {
22122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22123 }
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22131 PyObject *resultobj = 0;
22132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22133 bool arg2 ;
22134 void *argp1 = 0 ;
22135 int res1 = 0 ;
22136 bool val2 ;
22137 int ecode2 = 0 ;
22138 PyObject *swig_obj[2] ;
22139
22140 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22142 if (!SWIG_IsOK(res1)) {
22143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22144 }
22145 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22146 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22147 if (!SWIG_IsOK(ecode2)) {
22148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22149 }
22150 arg2 = static_cast< bool >(val2);
22151 if (arg1) (arg1)->m_controlDown = arg2;
22152
22153 resultobj = SWIG_Py_Void();
22154 return resultobj;
22155 fail:
22156 return NULL;
22157 }
22158
22159
22160 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 PyObject *resultobj = 0;
22162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22163 bool result;
22164 void *argp1 = 0 ;
22165 int res1 = 0 ;
22166 PyObject *swig_obj[1] ;
22167
22168 if (!args) SWIG_fail;
22169 swig_obj[0] = args;
22170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22171 if (!SWIG_IsOK(res1)) {
22172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22173 }
22174 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22175 result = (bool) ((arg1)->m_controlDown);
22176 {
22177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22178 }
22179 return resultobj;
22180 fail:
22181 return NULL;
22182 }
22183
22184
22185 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22186 PyObject *resultobj = 0;
22187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22188 bool arg2 ;
22189 void *argp1 = 0 ;
22190 int res1 = 0 ;
22191 bool val2 ;
22192 int ecode2 = 0 ;
22193 PyObject *swig_obj[2] ;
22194
22195 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22197 if (!SWIG_IsOK(res1)) {
22198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22199 }
22200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22201 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22202 if (!SWIG_IsOK(ecode2)) {
22203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22204 }
22205 arg2 = static_cast< bool >(val2);
22206 if (arg1) (arg1)->m_shiftDown = arg2;
22207
22208 resultobj = SWIG_Py_Void();
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22216 PyObject *resultobj = 0;
22217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22218 bool result;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject *swig_obj[1] ;
22222
22223 if (!args) SWIG_fail;
22224 swig_obj[0] = args;
22225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22226 if (!SWIG_IsOK(res1)) {
22227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22228 }
22229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22230 result = (bool) ((arg1)->m_shiftDown);
22231 {
22232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22233 }
22234 return resultobj;
22235 fail:
22236 return NULL;
22237 }
22238
22239
22240 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22241 PyObject *resultobj = 0;
22242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22243 bool arg2 ;
22244 void *argp1 = 0 ;
22245 int res1 = 0 ;
22246 bool val2 ;
22247 int ecode2 = 0 ;
22248 PyObject *swig_obj[2] ;
22249
22250 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22252 if (!SWIG_IsOK(res1)) {
22253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22254 }
22255 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22256 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22257 if (!SWIG_IsOK(ecode2)) {
22258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22259 }
22260 arg2 = static_cast< bool >(val2);
22261 if (arg1) (arg1)->m_altDown = arg2;
22262
22263 resultobj = SWIG_Py_Void();
22264 return resultobj;
22265 fail:
22266 return NULL;
22267 }
22268
22269
22270 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22271 PyObject *resultobj = 0;
22272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22273 bool result;
22274 void *argp1 = 0 ;
22275 int res1 = 0 ;
22276 PyObject *swig_obj[1] ;
22277
22278 if (!args) SWIG_fail;
22279 swig_obj[0] = args;
22280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22281 if (!SWIG_IsOK(res1)) {
22282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22283 }
22284 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22285 result = (bool) ((arg1)->m_altDown);
22286 {
22287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22288 }
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22296 PyObject *resultobj = 0;
22297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22298 bool arg2 ;
22299 void *argp1 = 0 ;
22300 int res1 = 0 ;
22301 bool val2 ;
22302 int ecode2 = 0 ;
22303 PyObject *swig_obj[2] ;
22304
22305 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22307 if (!SWIG_IsOK(res1)) {
22308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22309 }
22310 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22311 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22312 if (!SWIG_IsOK(ecode2)) {
22313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22314 }
22315 arg2 = static_cast< bool >(val2);
22316 if (arg1) (arg1)->m_metaDown = arg2;
22317
22318 resultobj = SWIG_Py_Void();
22319 return resultobj;
22320 fail:
22321 return NULL;
22322 }
22323
22324
22325 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22326 PyObject *resultobj = 0;
22327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22328 bool result;
22329 void *argp1 = 0 ;
22330 int res1 = 0 ;
22331 PyObject *swig_obj[1] ;
22332
22333 if (!args) SWIG_fail;
22334 swig_obj[0] = args;
22335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22336 if (!SWIG_IsOK(res1)) {
22337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22338 }
22339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22340 result = (bool) ((arg1)->m_metaDown);
22341 {
22342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22343 }
22344 return resultobj;
22345 fail:
22346 return NULL;
22347 }
22348
22349
22350 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22351 PyObject *resultobj = 0;
22352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22353 int arg2 ;
22354 void *argp1 = 0 ;
22355 int res1 = 0 ;
22356 int val2 ;
22357 int ecode2 = 0 ;
22358 PyObject *swig_obj[2] ;
22359
22360 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22362 if (!SWIG_IsOK(res1)) {
22363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22364 }
22365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22366 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22367 if (!SWIG_IsOK(ecode2)) {
22368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22369 }
22370 arg2 = static_cast< int >(val2);
22371 if (arg1) (arg1)->m_wheelRotation = arg2;
22372
22373 resultobj = SWIG_Py_Void();
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22383 int result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22393 }
22394 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22395 result = (int) ((arg1)->m_wheelRotation);
22396 resultobj = SWIG_From_int(static_cast< int >(result));
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22406 int arg2 ;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 int val2 ;
22410 int ecode2 = 0 ;
22411 PyObject *swig_obj[2] ;
22412
22413 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22415 if (!SWIG_IsOK(res1)) {
22416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22417 }
22418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22419 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22420 if (!SWIG_IsOK(ecode2)) {
22421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22422 }
22423 arg2 = static_cast< int >(val2);
22424 if (arg1) (arg1)->m_wheelDelta = arg2;
22425
22426 resultobj = SWIG_Py_Void();
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22436 int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22446 }
22447 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22448 result = (int) ((arg1)->m_wheelDelta);
22449 resultobj = SWIG_From_int(static_cast< int >(result));
22450 return resultobj;
22451 fail:
22452 return NULL;
22453 }
22454
22455
22456 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 PyObject *resultobj = 0;
22458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22459 int arg2 ;
22460 void *argp1 = 0 ;
22461 int res1 = 0 ;
22462 int val2 ;
22463 int ecode2 = 0 ;
22464 PyObject *swig_obj[2] ;
22465
22466 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22468 if (!SWIG_IsOK(res1)) {
22469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22470 }
22471 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22472 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22473 if (!SWIG_IsOK(ecode2)) {
22474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22475 }
22476 arg2 = static_cast< int >(val2);
22477 if (arg1) (arg1)->m_linesPerAction = arg2;
22478
22479 resultobj = SWIG_Py_Void();
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22487 PyObject *resultobj = 0;
22488 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22489 int result;
22490 void *argp1 = 0 ;
22491 int res1 = 0 ;
22492 PyObject *swig_obj[1] ;
22493
22494 if (!args) SWIG_fail;
22495 swig_obj[0] = args;
22496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22497 if (!SWIG_IsOK(res1)) {
22498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22499 }
22500 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22501 result = (int) ((arg1)->m_linesPerAction);
22502 resultobj = SWIG_From_int(static_cast< int >(result));
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22510 PyObject *obj;
22511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22512 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22513 return SWIG_Py_Void();
22514 }
22515
22516 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22517 return SWIG_Python_InitShadowInstance(args);
22518 }
22519
22520 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22521 PyObject *resultobj = 0;
22522 int arg1 = (int) 0 ;
22523 int arg2 = (int) 0 ;
22524 wxSetCursorEvent *result = 0 ;
22525 int val1 ;
22526 int ecode1 = 0 ;
22527 int val2 ;
22528 int ecode2 = 0 ;
22529 PyObject * obj0 = 0 ;
22530 PyObject * obj1 = 0 ;
22531 char * kwnames[] = {
22532 (char *) "x",(char *) "y", NULL
22533 };
22534
22535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22536 if (obj0) {
22537 ecode1 = SWIG_AsVal_int(obj0, &val1);
22538 if (!SWIG_IsOK(ecode1)) {
22539 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22540 }
22541 arg1 = static_cast< int >(val1);
22542 }
22543 if (obj1) {
22544 ecode2 = SWIG_AsVal_int(obj1, &val2);
22545 if (!SWIG_IsOK(ecode2)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22547 }
22548 arg2 = static_cast< int >(val2);
22549 }
22550 {
22551 PyThreadState* __tstate = wxPyBeginAllowThreads();
22552 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22553 wxPyEndAllowThreads(__tstate);
22554 if (PyErr_Occurred()) SWIG_fail;
22555 }
22556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22557 return resultobj;
22558 fail:
22559 return NULL;
22560 }
22561
22562
22563 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22564 PyObject *resultobj = 0;
22565 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22566 int result;
22567 void *argp1 = 0 ;
22568 int res1 = 0 ;
22569 PyObject *swig_obj[1] ;
22570
22571 if (!args) SWIG_fail;
22572 swig_obj[0] = args;
22573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22574 if (!SWIG_IsOK(res1)) {
22575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22576 }
22577 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22578 {
22579 PyThreadState* __tstate = wxPyBeginAllowThreads();
22580 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22581 wxPyEndAllowThreads(__tstate);
22582 if (PyErr_Occurred()) SWIG_fail;
22583 }
22584 resultobj = SWIG_From_int(static_cast< int >(result));
22585 return resultobj;
22586 fail:
22587 return NULL;
22588 }
22589
22590
22591 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22592 PyObject *resultobj = 0;
22593 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22594 int result;
22595 void *argp1 = 0 ;
22596 int res1 = 0 ;
22597 PyObject *swig_obj[1] ;
22598
22599 if (!args) SWIG_fail;
22600 swig_obj[0] = args;
22601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22602 if (!SWIG_IsOK(res1)) {
22603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22604 }
22605 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22606 {
22607 PyThreadState* __tstate = wxPyBeginAllowThreads();
22608 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22609 wxPyEndAllowThreads(__tstate);
22610 if (PyErr_Occurred()) SWIG_fail;
22611 }
22612 resultobj = SWIG_From_int(static_cast< int >(result));
22613 return resultobj;
22614 fail:
22615 return NULL;
22616 }
22617
22618
22619 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22620 PyObject *resultobj = 0;
22621 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22622 wxCursor *arg2 = 0 ;
22623 void *argp1 = 0 ;
22624 int res1 = 0 ;
22625 void *argp2 = 0 ;
22626 int res2 = 0 ;
22627 PyObject * obj0 = 0 ;
22628 PyObject * obj1 = 0 ;
22629 char * kwnames[] = {
22630 (char *) "self",(char *) "cursor", NULL
22631 };
22632
22633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22639 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22640 if (!SWIG_IsOK(res2)) {
22641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22642 }
22643 if (!argp2) {
22644 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22645 }
22646 arg2 = reinterpret_cast< wxCursor * >(argp2);
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 (arg1)->SetCursor((wxCursor const &)*arg2);
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_Py_Void();
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22661 PyObject *resultobj = 0;
22662 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22663 wxCursor *result = 0 ;
22664 void *argp1 = 0 ;
22665 int res1 = 0 ;
22666 PyObject *swig_obj[1] ;
22667
22668 if (!args) SWIG_fail;
22669 swig_obj[0] = args;
22670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22671 if (!SWIG_IsOK(res1)) {
22672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22673 }
22674 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22675 {
22676 PyThreadState* __tstate = wxPyBeginAllowThreads();
22677 {
22678 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22679 result = (wxCursor *) &_result_ref;
22680 }
22681 wxPyEndAllowThreads(__tstate);
22682 if (PyErr_Occurred()) SWIG_fail;
22683 }
22684 {
22685 wxCursor* resultptr = new wxCursor(*result);
22686 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22687 }
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22695 PyObject *resultobj = 0;
22696 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22697 bool result;
22698 void *argp1 = 0 ;
22699 int res1 = 0 ;
22700 PyObject *swig_obj[1] ;
22701
22702 if (!args) SWIG_fail;
22703 swig_obj[0] = args;
22704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22705 if (!SWIG_IsOK(res1)) {
22706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22707 }
22708 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22709 {
22710 PyThreadState* __tstate = wxPyBeginAllowThreads();
22711 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 {
22716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22717 }
22718 return resultobj;
22719 fail:
22720 return NULL;
22721 }
22722
22723
22724 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22725 PyObject *obj;
22726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22727 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22728 return SWIG_Py_Void();
22729 }
22730
22731 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22732 return SWIG_Python_InitShadowInstance(args);
22733 }
22734
22735 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22736 PyObject *resultobj = 0;
22737 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22738 wxKeyEvent *result = 0 ;
22739 int val1 ;
22740 int ecode1 = 0 ;
22741 PyObject * obj0 = 0 ;
22742 char * kwnames[] = {
22743 (char *) "eventType", NULL
22744 };
22745
22746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22747 if (obj0) {
22748 ecode1 = SWIG_AsVal_int(obj0, &val1);
22749 if (!SWIG_IsOK(ecode1)) {
22750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22751 }
22752 arg1 = static_cast< wxEventType >(val1);
22753 }
22754 {
22755 PyThreadState* __tstate = wxPyBeginAllowThreads();
22756 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22768 PyObject *resultobj = 0;
22769 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22770 int result;
22771 void *argp1 = 0 ;
22772 int res1 = 0 ;
22773 PyObject *swig_obj[1] ;
22774
22775 if (!args) SWIG_fail;
22776 swig_obj[0] = args;
22777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22778 if (!SWIG_IsOK(res1)) {
22779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22780 }
22781 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_From_int(static_cast< int >(result));
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22796 PyObject *resultobj = 0;
22797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22798 bool result;
22799 void *argp1 = 0 ;
22800 int res1 = 0 ;
22801 PyObject *swig_obj[1] ;
22802
22803 if (!args) SWIG_fail;
22804 swig_obj[0] = args;
22805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22806 if (!SWIG_IsOK(res1)) {
22807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22808 }
22809 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 PyObject *resultobj = 0;
22827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22828 bool result;
22829 void *argp1 = 0 ;
22830 int res1 = 0 ;
22831 PyObject *swig_obj[1] ;
22832
22833 if (!args) SWIG_fail;
22834 swig_obj[0] = args;
22835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22836 if (!SWIG_IsOK(res1)) {
22837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22838 }
22839 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22840 {
22841 PyThreadState* __tstate = wxPyBeginAllowThreads();
22842 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22843 wxPyEndAllowThreads(__tstate);
22844 if (PyErr_Occurred()) SWIG_fail;
22845 }
22846 {
22847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22848 }
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22858 bool result;
22859 void *argp1 = 0 ;
22860 int res1 = 0 ;
22861 PyObject *swig_obj[1] ;
22862
22863 if (!args) SWIG_fail;
22864 swig_obj[0] = args;
22865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22866 if (!SWIG_IsOK(res1)) {
22867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22868 }
22869 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22870 {
22871 PyThreadState* __tstate = wxPyBeginAllowThreads();
22872 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22873 wxPyEndAllowThreads(__tstate);
22874 if (PyErr_Occurred()) SWIG_fail;
22875 }
22876 {
22877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22878 }
22879 return resultobj;
22880 fail:
22881 return NULL;
22882 }
22883
22884
22885 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22886 PyObject *resultobj = 0;
22887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22888 bool result;
22889 void *argp1 = 0 ;
22890 int res1 = 0 ;
22891 PyObject *swig_obj[1] ;
22892
22893 if (!args) SWIG_fail;
22894 swig_obj[0] = args;
22895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22896 if (!SWIG_IsOK(res1)) {
22897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22898 }
22899 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22903 wxPyEndAllowThreads(__tstate);
22904 if (PyErr_Occurred()) SWIG_fail;
22905 }
22906 {
22907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22908 }
22909 return resultobj;
22910 fail:
22911 return NULL;
22912 }
22913
22914
22915 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22916 PyObject *resultobj = 0;
22917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22918 bool result;
22919 void *argp1 = 0 ;
22920 int res1 = 0 ;
22921 PyObject *swig_obj[1] ;
22922
22923 if (!args) SWIG_fail;
22924 swig_obj[0] = args;
22925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22926 if (!SWIG_IsOK(res1)) {
22927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22928 }
22929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22933 wxPyEndAllowThreads(__tstate);
22934 if (PyErr_Occurred()) SWIG_fail;
22935 }
22936 {
22937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22938 }
22939 return resultobj;
22940 fail:
22941 return NULL;
22942 }
22943
22944
22945 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22946 PyObject *resultobj = 0;
22947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22948 bool result;
22949 void *argp1 = 0 ;
22950 int res1 = 0 ;
22951 PyObject *swig_obj[1] ;
22952
22953 if (!args) SWIG_fail;
22954 swig_obj[0] = args;
22955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22958 }
22959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22960 {
22961 PyThreadState* __tstate = wxPyBeginAllowThreads();
22962 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 {
22967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22968 }
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 PyObject *resultobj = 0;
22977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22978 int result;
22979 void *argp1 = 0 ;
22980 int res1 = 0 ;
22981 PyObject *swig_obj[1] ;
22982
22983 if (!args) SWIG_fail;
22984 swig_obj[0] = args;
22985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22986 if (!SWIG_IsOK(res1)) {
22987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22988 }
22989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22993 wxPyEndAllowThreads(__tstate);
22994 if (PyErr_Occurred()) SWIG_fail;
22995 }
22996 resultobj = SWIG_From_int(static_cast< int >(result));
22997 return resultobj;
22998 fail:
22999 return NULL;
23000 }
23001
23002
23003 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23004 PyObject *resultobj = 0;
23005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23006 int result;
23007 void *argp1 = 0 ;
23008 int res1 = 0 ;
23009 PyObject *swig_obj[1] ;
23010
23011 if (!args) SWIG_fail;
23012 swig_obj[0] = args;
23013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23016 }
23017 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 resultobj = SWIG_From_int(static_cast< int >(result));
23025 return resultobj;
23026 fail:
23027 return NULL;
23028 }
23029
23030
23031 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23032 PyObject *resultobj = 0;
23033 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23034 int arg2 ;
23035 void *argp1 = 0 ;
23036 int res1 = 0 ;
23037 int val2 ;
23038 int ecode2 = 0 ;
23039 PyObject * obj0 = 0 ;
23040 PyObject * obj1 = 0 ;
23041 char * kwnames[] = {
23042 (char *) "self",(char *) "uniChar", NULL
23043 };
23044
23045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23047 if (!SWIG_IsOK(res1)) {
23048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23049 }
23050 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23051 ecode2 = SWIG_AsVal_int(obj1, &val2);
23052 if (!SWIG_IsOK(ecode2)) {
23053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23054 }
23055 arg2 = static_cast< int >(val2);
23056 {
23057 PyThreadState* __tstate = wxPyBeginAllowThreads();
23058 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23059 wxPyEndAllowThreads(__tstate);
23060 if (PyErr_Occurred()) SWIG_fail;
23061 }
23062 resultobj = SWIG_Py_Void();
23063 return resultobj;
23064 fail:
23065 return NULL;
23066 }
23067
23068
23069 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23070 PyObject *resultobj = 0;
23071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23072 unsigned int result;
23073 void *argp1 = 0 ;
23074 int res1 = 0 ;
23075 PyObject *swig_obj[1] ;
23076
23077 if (!args) SWIG_fail;
23078 swig_obj[0] = args;
23079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23080 if (!SWIG_IsOK(res1)) {
23081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23082 }
23083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23084 {
23085 PyThreadState* __tstate = wxPyBeginAllowThreads();
23086 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23087 wxPyEndAllowThreads(__tstate);
23088 if (PyErr_Occurred()) SWIG_fail;
23089 }
23090 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23098 PyObject *resultobj = 0;
23099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23100 unsigned int result;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 PyObject *swig_obj[1] ;
23104
23105 if (!args) SWIG_fail;
23106 swig_obj[0] = args;
23107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23108 if (!SWIG_IsOK(res1)) {
23109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23110 }
23111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23112 {
23113 PyThreadState* __tstate = wxPyBeginAllowThreads();
23114 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23115 wxPyEndAllowThreads(__tstate);
23116 if (PyErr_Occurred()) SWIG_fail;
23117 }
23118 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23119 return resultobj;
23120 fail:
23121 return NULL;
23122 }
23123
23124
23125 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23126 PyObject *resultobj = 0;
23127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23128 wxPoint result;
23129 void *argp1 = 0 ;
23130 int res1 = 0 ;
23131 PyObject *swig_obj[1] ;
23132
23133 if (!args) SWIG_fail;
23134 swig_obj[0] = args;
23135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23136 if (!SWIG_IsOK(res1)) {
23137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23138 }
23139 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23140 {
23141 PyThreadState* __tstate = wxPyBeginAllowThreads();
23142 result = (arg1)->GetPosition();
23143 wxPyEndAllowThreads(__tstate);
23144 if (PyErr_Occurred()) SWIG_fail;
23145 }
23146 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23147 return resultobj;
23148 fail:
23149 return NULL;
23150 }
23151
23152
23153 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23154 PyObject *resultobj = 0;
23155 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23156 long *arg2 = (long *) 0 ;
23157 long *arg3 = (long *) 0 ;
23158 void *argp1 = 0 ;
23159 int res1 = 0 ;
23160 long temp2 ;
23161 int res2 = SWIG_TMPOBJ ;
23162 long temp3 ;
23163 int res3 = SWIG_TMPOBJ ;
23164 PyObject *swig_obj[1] ;
23165
23166 arg2 = &temp2;
23167 arg3 = &temp3;
23168 if (!args) SWIG_fail;
23169 swig_obj[0] = args;
23170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23171 if (!SWIG_IsOK(res1)) {
23172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23173 }
23174 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23175 {
23176 PyThreadState* __tstate = wxPyBeginAllowThreads();
23177 (arg1)->GetPosition(arg2,arg3);
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 resultobj = SWIG_Py_Void();
23182 if (SWIG_IsTmpObj(res2)) {
23183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23184 } else {
23185 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23187 }
23188 if (SWIG_IsTmpObj(res3)) {
23189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23190 } else {
23191 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23193 }
23194 return resultobj;
23195 fail:
23196 return NULL;
23197 }
23198
23199
23200 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23201 PyObject *resultobj = 0;
23202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23203 int result;
23204 void *argp1 = 0 ;
23205 int res1 = 0 ;
23206 PyObject *swig_obj[1] ;
23207
23208 if (!args) SWIG_fail;
23209 swig_obj[0] = args;
23210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23211 if (!SWIG_IsOK(res1)) {
23212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23213 }
23214 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (int)((wxKeyEvent const *)arg1)->GetX();
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 resultobj = SWIG_From_int(static_cast< int >(result));
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *resultobj = 0;
23230 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23231 int result;
23232 void *argp1 = 0 ;
23233 int res1 = 0 ;
23234 PyObject *swig_obj[1] ;
23235
23236 if (!args) SWIG_fail;
23237 swig_obj[0] = args;
23238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23241 }
23242 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 result = (int)((wxKeyEvent const *)arg1)->GetY();
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_From_int(static_cast< int >(result));
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23257 PyObject *resultobj = 0;
23258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23259 int arg2 ;
23260 void *argp1 = 0 ;
23261 int res1 = 0 ;
23262 int val2 ;
23263 int ecode2 = 0 ;
23264 PyObject *swig_obj[2] ;
23265
23266 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23268 if (!SWIG_IsOK(res1)) {
23269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23270 }
23271 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23272 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23273 if (!SWIG_IsOK(ecode2)) {
23274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23275 }
23276 arg2 = static_cast< int >(val2);
23277 if (arg1) (arg1)->m_x = arg2;
23278
23279 resultobj = SWIG_Py_Void();
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23287 PyObject *resultobj = 0;
23288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23289 int result;
23290 void *argp1 = 0 ;
23291 int res1 = 0 ;
23292 PyObject *swig_obj[1] ;
23293
23294 if (!args) SWIG_fail;
23295 swig_obj[0] = args;
23296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23297 if (!SWIG_IsOK(res1)) {
23298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23299 }
23300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23301 result = (int) ((arg1)->m_x);
23302 resultobj = SWIG_From_int(static_cast< int >(result));
23303 return resultobj;
23304 fail:
23305 return NULL;
23306 }
23307
23308
23309 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23310 PyObject *resultobj = 0;
23311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23312 int arg2 ;
23313 void *argp1 = 0 ;
23314 int res1 = 0 ;
23315 int val2 ;
23316 int ecode2 = 0 ;
23317 PyObject *swig_obj[2] ;
23318
23319 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23321 if (!SWIG_IsOK(res1)) {
23322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23323 }
23324 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23325 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23326 if (!SWIG_IsOK(ecode2)) {
23327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23328 }
23329 arg2 = static_cast< int >(val2);
23330 if (arg1) (arg1)->m_y = arg2;
23331
23332 resultobj = SWIG_Py_Void();
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23340 PyObject *resultobj = 0;
23341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23342 int result;
23343 void *argp1 = 0 ;
23344 int res1 = 0 ;
23345 PyObject *swig_obj[1] ;
23346
23347 if (!args) SWIG_fail;
23348 swig_obj[0] = args;
23349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23350 if (!SWIG_IsOK(res1)) {
23351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23352 }
23353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23354 result = (int) ((arg1)->m_y);
23355 resultobj = SWIG_From_int(static_cast< int >(result));
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23363 PyObject *resultobj = 0;
23364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23365 long arg2 ;
23366 void *argp1 = 0 ;
23367 int res1 = 0 ;
23368 long val2 ;
23369 int ecode2 = 0 ;
23370 PyObject *swig_obj[2] ;
23371
23372 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23374 if (!SWIG_IsOK(res1)) {
23375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23376 }
23377 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23378 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23379 if (!SWIG_IsOK(ecode2)) {
23380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23381 }
23382 arg2 = static_cast< long >(val2);
23383 if (arg1) (arg1)->m_keyCode = arg2;
23384
23385 resultobj = SWIG_Py_Void();
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 PyObject *resultobj = 0;
23394 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23395 long result;
23396 void *argp1 = 0 ;
23397 int res1 = 0 ;
23398 PyObject *swig_obj[1] ;
23399
23400 if (!args) SWIG_fail;
23401 swig_obj[0] = args;
23402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23403 if (!SWIG_IsOK(res1)) {
23404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23405 }
23406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23407 result = (long) ((arg1)->m_keyCode);
23408 resultobj = SWIG_From_long(static_cast< long >(result));
23409 return resultobj;
23410 fail:
23411 return NULL;
23412 }
23413
23414
23415 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23416 PyObject *resultobj = 0;
23417 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23418 bool arg2 ;
23419 void *argp1 = 0 ;
23420 int res1 = 0 ;
23421 bool val2 ;
23422 int ecode2 = 0 ;
23423 PyObject *swig_obj[2] ;
23424
23425 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23427 if (!SWIG_IsOK(res1)) {
23428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23429 }
23430 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23431 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23432 if (!SWIG_IsOK(ecode2)) {
23433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23434 }
23435 arg2 = static_cast< bool >(val2);
23436 if (arg1) (arg1)->m_controlDown = arg2;
23437
23438 resultobj = SWIG_Py_Void();
23439 return resultobj;
23440 fail:
23441 return NULL;
23442 }
23443
23444
23445 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23446 PyObject *resultobj = 0;
23447 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23448 bool result;
23449 void *argp1 = 0 ;
23450 int res1 = 0 ;
23451 PyObject *swig_obj[1] ;
23452
23453 if (!args) SWIG_fail;
23454 swig_obj[0] = args;
23455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23456 if (!SWIG_IsOK(res1)) {
23457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23458 }
23459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23460 result = (bool) ((arg1)->m_controlDown);
23461 {
23462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23463 }
23464 return resultobj;
23465 fail:
23466 return NULL;
23467 }
23468
23469
23470 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23471 PyObject *resultobj = 0;
23472 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23473 bool arg2 ;
23474 void *argp1 = 0 ;
23475 int res1 = 0 ;
23476 bool val2 ;
23477 int ecode2 = 0 ;
23478 PyObject *swig_obj[2] ;
23479
23480 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23484 }
23485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23486 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23487 if (!SWIG_IsOK(ecode2)) {
23488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23489 }
23490 arg2 = static_cast< bool >(val2);
23491 if (arg1) (arg1)->m_shiftDown = arg2;
23492
23493 resultobj = SWIG_Py_Void();
23494 return resultobj;
23495 fail:
23496 return NULL;
23497 }
23498
23499
23500 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23501 PyObject *resultobj = 0;
23502 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23503 bool result;
23504 void *argp1 = 0 ;
23505 int res1 = 0 ;
23506 PyObject *swig_obj[1] ;
23507
23508 if (!args) SWIG_fail;
23509 swig_obj[0] = args;
23510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23511 if (!SWIG_IsOK(res1)) {
23512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23513 }
23514 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23515 result = (bool) ((arg1)->m_shiftDown);
23516 {
23517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23518 }
23519 return resultobj;
23520 fail:
23521 return NULL;
23522 }
23523
23524
23525 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23526 PyObject *resultobj = 0;
23527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23528 bool arg2 ;
23529 void *argp1 = 0 ;
23530 int res1 = 0 ;
23531 bool val2 ;
23532 int ecode2 = 0 ;
23533 PyObject *swig_obj[2] ;
23534
23535 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23537 if (!SWIG_IsOK(res1)) {
23538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23539 }
23540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23541 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23542 if (!SWIG_IsOK(ecode2)) {
23543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23544 }
23545 arg2 = static_cast< bool >(val2);
23546 if (arg1) (arg1)->m_altDown = arg2;
23547
23548 resultobj = SWIG_Py_Void();
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 PyObject *resultobj = 0;
23557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23558 bool result;
23559 void *argp1 = 0 ;
23560 int res1 = 0 ;
23561 PyObject *swig_obj[1] ;
23562
23563 if (!args) SWIG_fail;
23564 swig_obj[0] = args;
23565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23566 if (!SWIG_IsOK(res1)) {
23567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23568 }
23569 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23570 result = (bool) ((arg1)->m_altDown);
23571 {
23572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23573 }
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23581 PyObject *resultobj = 0;
23582 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23583 bool arg2 ;
23584 void *argp1 = 0 ;
23585 int res1 = 0 ;
23586 bool val2 ;
23587 int ecode2 = 0 ;
23588 PyObject *swig_obj[2] ;
23589
23590 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23592 if (!SWIG_IsOK(res1)) {
23593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23594 }
23595 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23596 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23597 if (!SWIG_IsOK(ecode2)) {
23598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23599 }
23600 arg2 = static_cast< bool >(val2);
23601 if (arg1) (arg1)->m_metaDown = arg2;
23602
23603 resultobj = SWIG_Py_Void();
23604 return resultobj;
23605 fail:
23606 return NULL;
23607 }
23608
23609
23610 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23611 PyObject *resultobj = 0;
23612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23613 bool result;
23614 void *argp1 = 0 ;
23615 int res1 = 0 ;
23616 PyObject *swig_obj[1] ;
23617
23618 if (!args) SWIG_fail;
23619 swig_obj[0] = args;
23620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23621 if (!SWIG_IsOK(res1)) {
23622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23623 }
23624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23625 result = (bool) ((arg1)->m_metaDown);
23626 {
23627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23628 }
23629 return resultobj;
23630 fail:
23631 return NULL;
23632 }
23633
23634
23635 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23636 PyObject *resultobj = 0;
23637 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23638 bool arg2 ;
23639 void *argp1 = 0 ;
23640 int res1 = 0 ;
23641 bool val2 ;
23642 int ecode2 = 0 ;
23643 PyObject *swig_obj[2] ;
23644
23645 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23647 if (!SWIG_IsOK(res1)) {
23648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23649 }
23650 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23651 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23652 if (!SWIG_IsOK(ecode2)) {
23653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23654 }
23655 arg2 = static_cast< bool >(val2);
23656 if (arg1) (arg1)->m_scanCode = arg2;
23657
23658 resultobj = SWIG_Py_Void();
23659 return resultobj;
23660 fail:
23661 return NULL;
23662 }
23663
23664
23665 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 PyObject *resultobj = 0;
23667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23668 bool result;
23669 void *argp1 = 0 ;
23670 int res1 = 0 ;
23671 PyObject *swig_obj[1] ;
23672
23673 if (!args) SWIG_fail;
23674 swig_obj[0] = args;
23675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23676 if (!SWIG_IsOK(res1)) {
23677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23678 }
23679 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23680 result = (bool) ((arg1)->m_scanCode);
23681 {
23682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23683 }
23684 return resultobj;
23685 fail:
23686 return NULL;
23687 }
23688
23689
23690 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23691 PyObject *resultobj = 0;
23692 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23693 unsigned int arg2 ;
23694 void *argp1 = 0 ;
23695 int res1 = 0 ;
23696 unsigned int val2 ;
23697 int ecode2 = 0 ;
23698 PyObject *swig_obj[2] ;
23699
23700 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23702 if (!SWIG_IsOK(res1)) {
23703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23704 }
23705 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23706 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23707 if (!SWIG_IsOK(ecode2)) {
23708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23709 }
23710 arg2 = static_cast< unsigned int >(val2);
23711 if (arg1) (arg1)->m_rawCode = arg2;
23712
23713 resultobj = SWIG_Py_Void();
23714 return resultobj;
23715 fail:
23716 return NULL;
23717 }
23718
23719
23720 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23721 PyObject *resultobj = 0;
23722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23723 unsigned int result;
23724 void *argp1 = 0 ;
23725 int res1 = 0 ;
23726 PyObject *swig_obj[1] ;
23727
23728 if (!args) SWIG_fail;
23729 swig_obj[0] = args;
23730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23731 if (!SWIG_IsOK(res1)) {
23732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23733 }
23734 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23735 result = (unsigned int) ((arg1)->m_rawCode);
23736 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23744 PyObject *resultobj = 0;
23745 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23746 unsigned int arg2 ;
23747 void *argp1 = 0 ;
23748 int res1 = 0 ;
23749 unsigned int val2 ;
23750 int ecode2 = 0 ;
23751 PyObject *swig_obj[2] ;
23752
23753 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23755 if (!SWIG_IsOK(res1)) {
23756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23757 }
23758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23759 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23760 if (!SWIG_IsOK(ecode2)) {
23761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23762 }
23763 arg2 = static_cast< unsigned int >(val2);
23764 if (arg1) (arg1)->m_rawFlags = arg2;
23765
23766 resultobj = SWIG_Py_Void();
23767 return resultobj;
23768 fail:
23769 return NULL;
23770 }
23771
23772
23773 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23774 PyObject *resultobj = 0;
23775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23776 unsigned int result;
23777 void *argp1 = 0 ;
23778 int res1 = 0 ;
23779 PyObject *swig_obj[1] ;
23780
23781 if (!args) SWIG_fail;
23782 swig_obj[0] = args;
23783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23784 if (!SWIG_IsOK(res1)) {
23785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23786 }
23787 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23788 result = (unsigned int) ((arg1)->m_rawFlags);
23789 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *obj;
23798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23799 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23800 return SWIG_Py_Void();
23801 }
23802
23803 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23804 return SWIG_Python_InitShadowInstance(args);
23805 }
23806
23807 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23808 PyObject *resultobj = 0;
23809 wxSize const &arg1_defvalue = wxDefaultSize ;
23810 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23811 int arg2 = (int) 0 ;
23812 wxSizeEvent *result = 0 ;
23813 wxSize temp1 ;
23814 int val2 ;
23815 int ecode2 = 0 ;
23816 PyObject * obj0 = 0 ;
23817 PyObject * obj1 = 0 ;
23818 char * kwnames[] = {
23819 (char *) "sz",(char *) "winid", NULL
23820 };
23821
23822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23823 if (obj0) {
23824 {
23825 arg1 = &temp1;
23826 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23827 }
23828 }
23829 if (obj1) {
23830 ecode2 = SWIG_AsVal_int(obj1, &val2);
23831 if (!SWIG_IsOK(ecode2)) {
23832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23833 }
23834 arg2 = static_cast< int >(val2);
23835 }
23836 {
23837 PyThreadState* __tstate = wxPyBeginAllowThreads();
23838 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23839 wxPyEndAllowThreads(__tstate);
23840 if (PyErr_Occurred()) SWIG_fail;
23841 }
23842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23843 return resultobj;
23844 fail:
23845 return NULL;
23846 }
23847
23848
23849 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23850 PyObject *resultobj = 0;
23851 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23852 wxSize result;
23853 void *argp1 = 0 ;
23854 int res1 = 0 ;
23855 PyObject *swig_obj[1] ;
23856
23857 if (!args) SWIG_fail;
23858 swig_obj[0] = args;
23859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23860 if (!SWIG_IsOK(res1)) {
23861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23862 }
23863 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23864 {
23865 PyThreadState* __tstate = wxPyBeginAllowThreads();
23866 result = ((wxSizeEvent const *)arg1)->GetSize();
23867 wxPyEndAllowThreads(__tstate);
23868 if (PyErr_Occurred()) SWIG_fail;
23869 }
23870 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23871 return resultobj;
23872 fail:
23873 return NULL;
23874 }
23875
23876
23877 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23878 PyObject *resultobj = 0;
23879 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23880 wxRect result;
23881 void *argp1 = 0 ;
23882 int res1 = 0 ;
23883 PyObject *swig_obj[1] ;
23884
23885 if (!args) SWIG_fail;
23886 swig_obj[0] = args;
23887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23888 if (!SWIG_IsOK(res1)) {
23889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23890 }
23891 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23892 {
23893 PyThreadState* __tstate = wxPyBeginAllowThreads();
23894 result = ((wxSizeEvent const *)arg1)->GetRect();
23895 wxPyEndAllowThreads(__tstate);
23896 if (PyErr_Occurred()) SWIG_fail;
23897 }
23898 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23899 return resultobj;
23900 fail:
23901 return NULL;
23902 }
23903
23904
23905 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23906 PyObject *resultobj = 0;
23907 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23908 wxRect arg2 ;
23909 void *argp1 = 0 ;
23910 int res1 = 0 ;
23911 void *argp2 ;
23912 int res2 = 0 ;
23913 PyObject * obj0 = 0 ;
23914 PyObject * obj1 = 0 ;
23915 char * kwnames[] = {
23916 (char *) "self",(char *) "rect", NULL
23917 };
23918
23919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23921 if (!SWIG_IsOK(res1)) {
23922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23923 }
23924 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23925 {
23926 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23927 if (!SWIG_IsOK(res2)) {
23928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23929 }
23930 if (!argp2) {
23931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23932 } else {
23933 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23934 arg2 = *temp;
23935 if (SWIG_IsNewObj(res2)) delete temp;
23936 }
23937 }
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 (arg1)->SetRect(arg2);
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_Py_Void();
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj = 0;
23953 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23954 wxSize arg2 ;
23955 void *argp1 = 0 ;
23956 int res1 = 0 ;
23957 void *argp2 ;
23958 int res2 = 0 ;
23959 PyObject * obj0 = 0 ;
23960 PyObject * obj1 = 0 ;
23961 char * kwnames[] = {
23962 (char *) "self",(char *) "size", NULL
23963 };
23964
23965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23967 if (!SWIG_IsOK(res1)) {
23968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23969 }
23970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23971 {
23972 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23973 if (!SWIG_IsOK(res2)) {
23974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23975 }
23976 if (!argp2) {
23977 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23978 } else {
23979 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23980 arg2 = *temp;
23981 if (SWIG_IsNewObj(res2)) delete temp;
23982 }
23983 }
23984 {
23985 PyThreadState* __tstate = wxPyBeginAllowThreads();
23986 wxSizeEvent_SetSize(arg1,arg2);
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 resultobj = SWIG_Py_Void();
23991 return resultobj;
23992 fail:
23993 return NULL;
23994 }
23995
23996
23997 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23998 PyObject *resultobj = 0;
23999 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24000 wxSize *arg2 = (wxSize *) 0 ;
24001 void *argp1 = 0 ;
24002 int res1 = 0 ;
24003 void *argp2 = 0 ;
24004 int res2 = 0 ;
24005 PyObject *swig_obj[2] ;
24006
24007 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24009 if (!SWIG_IsOK(res1)) {
24010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24011 }
24012 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24013 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24014 if (!SWIG_IsOK(res2)) {
24015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24016 }
24017 arg2 = reinterpret_cast< wxSize * >(argp2);
24018 if (arg1) (arg1)->m_size = *arg2;
24019
24020 resultobj = SWIG_Py_Void();
24021 return resultobj;
24022 fail:
24023 return NULL;
24024 }
24025
24026
24027 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24028 PyObject *resultobj = 0;
24029 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24030 wxSize *result = 0 ;
24031 void *argp1 = 0 ;
24032 int res1 = 0 ;
24033 PyObject *swig_obj[1] ;
24034
24035 if (!args) SWIG_fail;
24036 swig_obj[0] = args;
24037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24038 if (!SWIG_IsOK(res1)) {
24039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24040 }
24041 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24042 result = (wxSize *)& ((arg1)->m_size);
24043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24051 PyObject *resultobj = 0;
24052 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24053 wxRect *arg2 = (wxRect *) 0 ;
24054 void *argp1 = 0 ;
24055 int res1 = 0 ;
24056 void *argp2 = 0 ;
24057 int res2 = 0 ;
24058 PyObject *swig_obj[2] ;
24059
24060 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24062 if (!SWIG_IsOK(res1)) {
24063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24064 }
24065 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24066 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24067 if (!SWIG_IsOK(res2)) {
24068 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24069 }
24070 arg2 = reinterpret_cast< wxRect * >(argp2);
24071 if (arg1) (arg1)->m_rect = *arg2;
24072
24073 resultobj = SWIG_Py_Void();
24074 return resultobj;
24075 fail:
24076 return NULL;
24077 }
24078
24079
24080 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24081 PyObject *resultobj = 0;
24082 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24083 wxRect *result = 0 ;
24084 void *argp1 = 0 ;
24085 int res1 = 0 ;
24086 PyObject *swig_obj[1] ;
24087
24088 if (!args) SWIG_fail;
24089 swig_obj[0] = args;
24090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24091 if (!SWIG_IsOK(res1)) {
24092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24093 }
24094 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24095 result = (wxRect *)& ((arg1)->m_rect);
24096 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24097 return resultobj;
24098 fail:
24099 return NULL;
24100 }
24101
24102
24103 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24104 PyObject *obj;
24105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24106 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24107 return SWIG_Py_Void();
24108 }
24109
24110 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24111 return SWIG_Python_InitShadowInstance(args);
24112 }
24113
24114 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24115 PyObject *resultobj = 0;
24116 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24117 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24118 int arg2 = (int) 0 ;
24119 wxMoveEvent *result = 0 ;
24120 wxPoint temp1 ;
24121 int val2 ;
24122 int ecode2 = 0 ;
24123 PyObject * obj0 = 0 ;
24124 PyObject * obj1 = 0 ;
24125 char * kwnames[] = {
24126 (char *) "pos",(char *) "winid", NULL
24127 };
24128
24129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24130 if (obj0) {
24131 {
24132 arg1 = &temp1;
24133 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24134 }
24135 }
24136 if (obj1) {
24137 ecode2 = SWIG_AsVal_int(obj1, &val2);
24138 if (!SWIG_IsOK(ecode2)) {
24139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24140 }
24141 arg2 = static_cast< int >(val2);
24142 }
24143 {
24144 PyThreadState* __tstate = wxPyBeginAllowThreads();
24145 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24146 wxPyEndAllowThreads(__tstate);
24147 if (PyErr_Occurred()) SWIG_fail;
24148 }
24149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24150 return resultobj;
24151 fail:
24152 return NULL;
24153 }
24154
24155
24156 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24157 PyObject *resultobj = 0;
24158 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24159 wxPoint result;
24160 void *argp1 = 0 ;
24161 int res1 = 0 ;
24162 PyObject *swig_obj[1] ;
24163
24164 if (!args) SWIG_fail;
24165 swig_obj[0] = args;
24166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24167 if (!SWIG_IsOK(res1)) {
24168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24169 }
24170 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 result = ((wxMoveEvent const *)arg1)->GetPosition();
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24187 wxRect result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24197 }
24198 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = ((wxMoveEvent const *)arg1)->GetRect();
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj = 0;
24214 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24215 wxRect *arg2 = 0 ;
24216 void *argp1 = 0 ;
24217 int res1 = 0 ;
24218 wxRect temp2 ;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 char * kwnames[] = {
24222 (char *) "self",(char *) "rect", NULL
24223 };
24224
24225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24231 {
24232 arg2 = &temp2;
24233 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24234 }
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 (arg1)->SetRect((wxRect const &)*arg2);
24238 wxPyEndAllowThreads(__tstate);
24239 if (PyErr_Occurred()) SWIG_fail;
24240 }
24241 resultobj = SWIG_Py_Void();
24242 return resultobj;
24243 fail:
24244 return NULL;
24245 }
24246
24247
24248 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24249 PyObject *resultobj = 0;
24250 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24251 wxPoint *arg2 = 0 ;
24252 void *argp1 = 0 ;
24253 int res1 = 0 ;
24254 wxPoint temp2 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char * kwnames[] = {
24258 (char *) "self",(char *) "pos", NULL
24259 };
24260
24261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24265 }
24266 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24267 {
24268 arg2 = &temp2;
24269 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24270 }
24271 {
24272 PyThreadState* __tstate = wxPyBeginAllowThreads();
24273 (arg1)->SetPosition((wxPoint const &)*arg2);
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 resultobj = SWIG_Py_Void();
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24285 PyObject *obj;
24286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24287 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24288 return SWIG_Py_Void();
24289 }
24290
24291 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24292 return SWIG_Python_InitShadowInstance(args);
24293 }
24294
24295 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj = 0;
24297 int arg1 = (int) 0 ;
24298 wxPaintEvent *result = 0 ;
24299 int val1 ;
24300 int ecode1 = 0 ;
24301 PyObject * obj0 = 0 ;
24302 char * kwnames[] = {
24303 (char *) "Id", NULL
24304 };
24305
24306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24307 if (obj0) {
24308 ecode1 = SWIG_AsVal_int(obj0, &val1);
24309 if (!SWIG_IsOK(ecode1)) {
24310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24311 }
24312 arg1 = static_cast< int >(val1);
24313 }
24314 {
24315 PyThreadState* __tstate = wxPyBeginAllowThreads();
24316 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24317 wxPyEndAllowThreads(__tstate);
24318 if (PyErr_Occurred()) SWIG_fail;
24319 }
24320 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24321 return resultobj;
24322 fail:
24323 return NULL;
24324 }
24325
24326
24327 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24328 PyObject *obj;
24329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24330 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24331 return SWIG_Py_Void();
24332 }
24333
24334 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 return SWIG_Python_InitShadowInstance(args);
24336 }
24337
24338 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24339 PyObject *resultobj = 0;
24340 int arg1 = (int) 0 ;
24341 wxNcPaintEvent *result = 0 ;
24342 int val1 ;
24343 int ecode1 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 char * kwnames[] = {
24346 (char *) "winid", NULL
24347 };
24348
24349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24350 if (obj0) {
24351 ecode1 = SWIG_AsVal_int(obj0, &val1);
24352 if (!SWIG_IsOK(ecode1)) {
24353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24354 }
24355 arg1 = static_cast< int >(val1);
24356 }
24357 {
24358 PyThreadState* __tstate = wxPyBeginAllowThreads();
24359 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24360 wxPyEndAllowThreads(__tstate);
24361 if (PyErr_Occurred()) SWIG_fail;
24362 }
24363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24371 PyObject *obj;
24372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24373 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24374 return SWIG_Py_Void();
24375 }
24376
24377 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24378 return SWIG_Python_InitShadowInstance(args);
24379 }
24380
24381 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24382 PyObject *resultobj = 0;
24383 int arg1 = (int) 0 ;
24384 wxDC *arg2 = (wxDC *) NULL ;
24385 wxEraseEvent *result = 0 ;
24386 int val1 ;
24387 int ecode1 = 0 ;
24388 void *argp2 = 0 ;
24389 int res2 = 0 ;
24390 PyObject * obj0 = 0 ;
24391 PyObject * obj1 = 0 ;
24392 char * kwnames[] = {
24393 (char *) "Id",(char *) "dc", NULL
24394 };
24395
24396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24397 if (obj0) {
24398 ecode1 = SWIG_AsVal_int(obj0, &val1);
24399 if (!SWIG_IsOK(ecode1)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24401 }
24402 arg1 = static_cast< int >(val1);
24403 }
24404 if (obj1) {
24405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24406 if (!SWIG_IsOK(res2)) {
24407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24408 }
24409 arg2 = reinterpret_cast< wxDC * >(argp2);
24410 }
24411 {
24412 PyThreadState* __tstate = wxPyBeginAllowThreads();
24413 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24425 PyObject *resultobj = 0;
24426 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24427 wxDC *result = 0 ;
24428 void *argp1 = 0 ;
24429 int res1 = 0 ;
24430 PyObject *swig_obj[1] ;
24431
24432 if (!args) SWIG_fail;
24433 swig_obj[0] = args;
24434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24435 if (!SWIG_IsOK(res1)) {
24436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24437 }
24438 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24439 {
24440 PyThreadState* __tstate = wxPyBeginAllowThreads();
24441 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 {
24446 resultobj = wxPyMake_wxObject(result, (bool)0);
24447 }
24448 return resultobj;
24449 fail:
24450 return NULL;
24451 }
24452
24453
24454 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24455 PyObject *obj;
24456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24457 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24458 return SWIG_Py_Void();
24459 }
24460
24461 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 return SWIG_Python_InitShadowInstance(args);
24463 }
24464
24465 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24466 PyObject *resultobj = 0;
24467 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24468 int arg2 = (int) 0 ;
24469 wxFocusEvent *result = 0 ;
24470 int val1 ;
24471 int ecode1 = 0 ;
24472 int val2 ;
24473 int ecode2 = 0 ;
24474 PyObject * obj0 = 0 ;
24475 PyObject * obj1 = 0 ;
24476 char * kwnames[] = {
24477 (char *) "type",(char *) "winid", NULL
24478 };
24479
24480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24481 if (obj0) {
24482 ecode1 = SWIG_AsVal_int(obj0, &val1);
24483 if (!SWIG_IsOK(ecode1)) {
24484 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24485 }
24486 arg1 = static_cast< wxEventType >(val1);
24487 }
24488 if (obj1) {
24489 ecode2 = SWIG_AsVal_int(obj1, &val2);
24490 if (!SWIG_IsOK(ecode2)) {
24491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24492 }
24493 arg2 = static_cast< int >(val2);
24494 }
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24509 PyObject *resultobj = 0;
24510 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24511 wxWindow *result = 0 ;
24512 void *argp1 = 0 ;
24513 int res1 = 0 ;
24514 PyObject *swig_obj[1] ;
24515
24516 if (!args) SWIG_fail;
24517 swig_obj[0] = args;
24518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24519 if (!SWIG_IsOK(res1)) {
24520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24521 }
24522 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24523 {
24524 PyThreadState* __tstate = wxPyBeginAllowThreads();
24525 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 resultobj = wxPyMake_wxObject(result, (bool)0);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj = 0;
24540 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24541 wxWindow *arg2 = (wxWindow *) 0 ;
24542 void *argp1 = 0 ;
24543 int res1 = 0 ;
24544 void *argp2 = 0 ;
24545 int res2 = 0 ;
24546 PyObject * obj0 = 0 ;
24547 PyObject * obj1 = 0 ;
24548 char * kwnames[] = {
24549 (char *) "self",(char *) "win", NULL
24550 };
24551
24552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24554 if (!SWIG_IsOK(res1)) {
24555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24556 }
24557 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24559 if (!SWIG_IsOK(res2)) {
24560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24561 }
24562 arg2 = reinterpret_cast< wxWindow * >(argp2);
24563 {
24564 PyThreadState* __tstate = wxPyBeginAllowThreads();
24565 (arg1)->SetWindow(arg2);
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 resultobj = SWIG_Py_Void();
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24577 PyObject *obj;
24578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24579 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24580 return SWIG_Py_Void();
24581 }
24582
24583 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24584 return SWIG_Python_InitShadowInstance(args);
24585 }
24586
24587 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24588 PyObject *resultobj = 0;
24589 wxWindow *arg1 = (wxWindow *) NULL ;
24590 wxChildFocusEvent *result = 0 ;
24591 void *argp1 = 0 ;
24592 int res1 = 0 ;
24593 PyObject * obj0 = 0 ;
24594 char * kwnames[] = {
24595 (char *) "win", NULL
24596 };
24597
24598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24599 if (obj0) {
24600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24601 if (!SWIG_IsOK(res1)) {
24602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24603 }
24604 arg1 = reinterpret_cast< wxWindow * >(argp1);
24605 }
24606 {
24607 PyThreadState* __tstate = wxPyBeginAllowThreads();
24608 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24609 wxPyEndAllowThreads(__tstate);
24610 if (PyErr_Occurred()) SWIG_fail;
24611 }
24612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24620 PyObject *resultobj = 0;
24621 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24622 wxWindow *result = 0 ;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 PyObject *swig_obj[1] ;
24626
24627 if (!args) SWIG_fail;
24628 swig_obj[0] = args;
24629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24630 if (!SWIG_IsOK(res1)) {
24631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24632 }
24633 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24637 wxPyEndAllowThreads(__tstate);
24638 if (PyErr_Occurred()) SWIG_fail;
24639 }
24640 {
24641 resultobj = wxPyMake_wxObject(result, (bool)0);
24642 }
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24650 PyObject *obj;
24651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24652 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24653 return SWIG_Py_Void();
24654 }
24655
24656 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24657 return SWIG_Python_InitShadowInstance(args);
24658 }
24659
24660 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj = 0;
24662 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24663 bool arg2 = (bool) true ;
24664 int arg3 = (int) 0 ;
24665 wxActivateEvent *result = 0 ;
24666 int val1 ;
24667 int ecode1 = 0 ;
24668 bool val2 ;
24669 int ecode2 = 0 ;
24670 int val3 ;
24671 int ecode3 = 0 ;
24672 PyObject * obj0 = 0 ;
24673 PyObject * obj1 = 0 ;
24674 PyObject * obj2 = 0 ;
24675 char * kwnames[] = {
24676 (char *) "type",(char *) "active",(char *) "Id", NULL
24677 };
24678
24679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24680 if (obj0) {
24681 ecode1 = SWIG_AsVal_int(obj0, &val1);
24682 if (!SWIG_IsOK(ecode1)) {
24683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24684 }
24685 arg1 = static_cast< wxEventType >(val1);
24686 }
24687 if (obj1) {
24688 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24689 if (!SWIG_IsOK(ecode2)) {
24690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24691 }
24692 arg2 = static_cast< bool >(val2);
24693 }
24694 if (obj2) {
24695 ecode3 = SWIG_AsVal_int(obj2, &val3);
24696 if (!SWIG_IsOK(ecode3)) {
24697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24698 }
24699 arg3 = static_cast< int >(val3);
24700 }
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24704 wxPyEndAllowThreads(__tstate);
24705 if (PyErr_Occurred()) SWIG_fail;
24706 }
24707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24708 return resultobj;
24709 fail:
24710 return NULL;
24711 }
24712
24713
24714 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24715 PyObject *resultobj = 0;
24716 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24717 bool result;
24718 void *argp1 = 0 ;
24719 int res1 = 0 ;
24720 PyObject *swig_obj[1] ;
24721
24722 if (!args) SWIG_fail;
24723 swig_obj[0] = args;
24724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24725 if (!SWIG_IsOK(res1)) {
24726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24727 }
24728 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24729 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 {
24736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24737 }
24738 return resultobj;
24739 fail:
24740 return NULL;
24741 }
24742
24743
24744 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24745 PyObject *obj;
24746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24747 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24748 return SWIG_Py_Void();
24749 }
24750
24751 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 return SWIG_Python_InitShadowInstance(args);
24753 }
24754
24755 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj = 0;
24757 int arg1 = (int) 0 ;
24758 wxInitDialogEvent *result = 0 ;
24759 int val1 ;
24760 int ecode1 = 0 ;
24761 PyObject * obj0 = 0 ;
24762 char * kwnames[] = {
24763 (char *) "Id", NULL
24764 };
24765
24766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24767 if (obj0) {
24768 ecode1 = SWIG_AsVal_int(obj0, &val1);
24769 if (!SWIG_IsOK(ecode1)) {
24770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24771 }
24772 arg1 = static_cast< int >(val1);
24773 }
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24777 wxPyEndAllowThreads(__tstate);
24778 if (PyErr_Occurred()) SWIG_fail;
24779 }
24780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24781 return resultobj;
24782 fail:
24783 return NULL;
24784 }
24785
24786
24787 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24788 PyObject *obj;
24789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24790 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24791 return SWIG_Py_Void();
24792 }
24793
24794 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24795 return SWIG_Python_InitShadowInstance(args);
24796 }
24797
24798 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24799 PyObject *resultobj = 0;
24800 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24801 int arg2 = (int) 0 ;
24802 wxMenu *arg3 = (wxMenu *) NULL ;
24803 wxMenuEvent *result = 0 ;
24804 int val1 ;
24805 int ecode1 = 0 ;
24806 int val2 ;
24807 int ecode2 = 0 ;
24808 void *argp3 = 0 ;
24809 int res3 = 0 ;
24810 PyObject * obj0 = 0 ;
24811 PyObject * obj1 = 0 ;
24812 PyObject * obj2 = 0 ;
24813 char * kwnames[] = {
24814 (char *) "type",(char *) "winid",(char *) "menu", NULL
24815 };
24816
24817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24818 if (obj0) {
24819 ecode1 = SWIG_AsVal_int(obj0, &val1);
24820 if (!SWIG_IsOK(ecode1)) {
24821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24822 }
24823 arg1 = static_cast< wxEventType >(val1);
24824 }
24825 if (obj1) {
24826 ecode2 = SWIG_AsVal_int(obj1, &val2);
24827 if (!SWIG_IsOK(ecode2)) {
24828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24829 }
24830 arg2 = static_cast< int >(val2);
24831 }
24832 if (obj2) {
24833 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24834 if (!SWIG_IsOK(res3)) {
24835 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24836 }
24837 arg3 = reinterpret_cast< wxMenu * >(argp3);
24838 }
24839 {
24840 PyThreadState* __tstate = wxPyBeginAllowThreads();
24841 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24842 wxPyEndAllowThreads(__tstate);
24843 if (PyErr_Occurred()) SWIG_fail;
24844 }
24845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24853 PyObject *resultobj = 0;
24854 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24855 int result;
24856 void *argp1 = 0 ;
24857 int res1 = 0 ;
24858 PyObject *swig_obj[1] ;
24859
24860 if (!args) SWIG_fail;
24861 swig_obj[0] = args;
24862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24863 if (!SWIG_IsOK(res1)) {
24864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24865 }
24866 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24867 {
24868 PyThreadState* __tstate = wxPyBeginAllowThreads();
24869 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 resultobj = SWIG_From_int(static_cast< int >(result));
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24881 PyObject *resultobj = 0;
24882 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24883 bool result;
24884 void *argp1 = 0 ;
24885 int res1 = 0 ;
24886 PyObject *swig_obj[1] ;
24887
24888 if (!args) SWIG_fail;
24889 swig_obj[0] = args;
24890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24893 }
24894 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24895 {
24896 PyThreadState* __tstate = wxPyBeginAllowThreads();
24897 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24898 wxPyEndAllowThreads(__tstate);
24899 if (PyErr_Occurred()) SWIG_fail;
24900 }
24901 {
24902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24903 }
24904 return resultobj;
24905 fail:
24906 return NULL;
24907 }
24908
24909
24910 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24911 PyObject *resultobj = 0;
24912 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24913 wxMenu *result = 0 ;
24914 void *argp1 = 0 ;
24915 int res1 = 0 ;
24916 PyObject *swig_obj[1] ;
24917
24918 if (!args) SWIG_fail;
24919 swig_obj[0] = args;
24920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24921 if (!SWIG_IsOK(res1)) {
24922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24923 }
24924 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24925 {
24926 PyThreadState* __tstate = wxPyBeginAllowThreads();
24927 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24928 wxPyEndAllowThreads(__tstate);
24929 if (PyErr_Occurred()) SWIG_fail;
24930 }
24931 {
24932 resultobj = wxPyMake_wxObject(result, (bool)0);
24933 }
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24941 PyObject *obj;
24942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24943 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24944 return SWIG_Py_Void();
24945 }
24946
24947 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24948 return SWIG_Python_InitShadowInstance(args);
24949 }
24950
24951 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24952 PyObject *resultobj = 0;
24953 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24954 int arg2 = (int) 0 ;
24955 wxCloseEvent *result = 0 ;
24956 int val1 ;
24957 int ecode1 = 0 ;
24958 int val2 ;
24959 int ecode2 = 0 ;
24960 PyObject * obj0 = 0 ;
24961 PyObject * obj1 = 0 ;
24962 char * kwnames[] = {
24963 (char *) "type",(char *) "winid", NULL
24964 };
24965
24966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24967 if (obj0) {
24968 ecode1 = SWIG_AsVal_int(obj0, &val1);
24969 if (!SWIG_IsOK(ecode1)) {
24970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24971 }
24972 arg1 = static_cast< wxEventType >(val1);
24973 }
24974 if (obj1) {
24975 ecode2 = SWIG_AsVal_int(obj1, &val2);
24976 if (!SWIG_IsOK(ecode2)) {
24977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24978 }
24979 arg2 = static_cast< int >(val2);
24980 }
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj = 0;
24996 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24997 bool arg2 ;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 bool val2 ;
25001 int ecode2 = 0 ;
25002 PyObject * obj0 = 0 ;
25003 PyObject * obj1 = 0 ;
25004 char * kwnames[] = {
25005 (char *) "self",(char *) "logOff", NULL
25006 };
25007
25008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25012 }
25013 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25014 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25015 if (!SWIG_IsOK(ecode2)) {
25016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25017 }
25018 arg2 = static_cast< bool >(val2);
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 (arg1)->SetLoggingOff(arg2);
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 resultobj = SWIG_Py_Void();
25026 return resultobj;
25027 fail:
25028 return NULL;
25029 }
25030
25031
25032 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25033 PyObject *resultobj = 0;
25034 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25035 bool result;
25036 void *argp1 = 0 ;
25037 int res1 = 0 ;
25038 PyObject *swig_obj[1] ;
25039
25040 if (!args) SWIG_fail;
25041 swig_obj[0] = args;
25042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25043 if (!SWIG_IsOK(res1)) {
25044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25045 }
25046 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25047 {
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 {
25054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25055 }
25056 return resultobj;
25057 fail:
25058 return NULL;
25059 }
25060
25061
25062 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25063 PyObject *resultobj = 0;
25064 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25065 bool arg2 = (bool) true ;
25066 void *argp1 = 0 ;
25067 int res1 = 0 ;
25068 bool val2 ;
25069 int ecode2 = 0 ;
25070 PyObject * obj0 = 0 ;
25071 PyObject * obj1 = 0 ;
25072 char * kwnames[] = {
25073 (char *) "self",(char *) "veto", NULL
25074 };
25075
25076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25078 if (!SWIG_IsOK(res1)) {
25079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25080 }
25081 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25082 if (obj1) {
25083 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25084 if (!SWIG_IsOK(ecode2)) {
25085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25086 }
25087 arg2 = static_cast< bool >(val2);
25088 }
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 (arg1)->Veto(arg2);
25092 wxPyEndAllowThreads(__tstate);
25093 if (PyErr_Occurred()) SWIG_fail;
25094 }
25095 resultobj = SWIG_Py_Void();
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25103 PyObject *resultobj = 0;
25104 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25105 bool result;
25106 void *argp1 = 0 ;
25107 int res1 = 0 ;
25108 PyObject *swig_obj[1] ;
25109
25110 if (!args) SWIG_fail;
25111 swig_obj[0] = args;
25112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25115 }
25116 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 {
25124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25125 }
25126 return resultobj;
25127 fail:
25128 return NULL;
25129 }
25130
25131
25132 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25133 PyObject *resultobj = 0;
25134 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25135 bool arg2 ;
25136 void *argp1 = 0 ;
25137 int res1 = 0 ;
25138 bool val2 ;
25139 int ecode2 = 0 ;
25140 PyObject * obj0 = 0 ;
25141 PyObject * obj1 = 0 ;
25142 char * kwnames[] = {
25143 (char *) "self",(char *) "canVeto", NULL
25144 };
25145
25146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25148 if (!SWIG_IsOK(res1)) {
25149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25150 }
25151 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25152 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25153 if (!SWIG_IsOK(ecode2)) {
25154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25155 }
25156 arg2 = static_cast< bool >(val2);
25157 {
25158 PyThreadState* __tstate = wxPyBeginAllowThreads();
25159 (arg1)->SetCanVeto(arg2);
25160 wxPyEndAllowThreads(__tstate);
25161 if (PyErr_Occurred()) SWIG_fail;
25162 }
25163 resultobj = SWIG_Py_Void();
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25171 PyObject *resultobj = 0;
25172 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25173 bool result;
25174 void *argp1 = 0 ;
25175 int res1 = 0 ;
25176 PyObject *swig_obj[1] ;
25177
25178 if (!args) SWIG_fail;
25179 swig_obj[0] = args;
25180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25181 if (!SWIG_IsOK(res1)) {
25182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25183 }
25184 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 {
25192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25193 }
25194 return resultobj;
25195 fail:
25196 return NULL;
25197 }
25198
25199
25200 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25201 PyObject *obj;
25202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25203 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25204 return SWIG_Py_Void();
25205 }
25206
25207 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25208 return SWIG_Python_InitShadowInstance(args);
25209 }
25210
25211 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25212 PyObject *resultobj = 0;
25213 int arg1 = (int) 0 ;
25214 bool arg2 = (bool) false ;
25215 wxShowEvent *result = 0 ;
25216 int val1 ;
25217 int ecode1 = 0 ;
25218 bool val2 ;
25219 int ecode2 = 0 ;
25220 PyObject * obj0 = 0 ;
25221 PyObject * obj1 = 0 ;
25222 char * kwnames[] = {
25223 (char *) "winid",(char *) "show", NULL
25224 };
25225
25226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25227 if (obj0) {
25228 ecode1 = SWIG_AsVal_int(obj0, &val1);
25229 if (!SWIG_IsOK(ecode1)) {
25230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25231 }
25232 arg1 = static_cast< int >(val1);
25233 }
25234 if (obj1) {
25235 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25236 if (!SWIG_IsOK(ecode2)) {
25237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25238 }
25239 arg2 = static_cast< bool >(val2);
25240 }
25241 {
25242 PyThreadState* __tstate = wxPyBeginAllowThreads();
25243 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25248 return resultobj;
25249 fail:
25250 return NULL;
25251 }
25252
25253
25254 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj = 0;
25256 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25257 bool arg2 ;
25258 void *argp1 = 0 ;
25259 int res1 = 0 ;
25260 bool val2 ;
25261 int ecode2 = 0 ;
25262 PyObject * obj0 = 0 ;
25263 PyObject * obj1 = 0 ;
25264 char * kwnames[] = {
25265 (char *) "self",(char *) "show", NULL
25266 };
25267
25268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25270 if (!SWIG_IsOK(res1)) {
25271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25272 }
25273 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25274 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25275 if (!SWIG_IsOK(ecode2)) {
25276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25277 }
25278 arg2 = static_cast< bool >(val2);
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 (arg1)->SetShow(arg2);
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_Py_Void();
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25293 PyObject *resultobj = 0;
25294 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25295 bool result;
25296 void *argp1 = 0 ;
25297 int res1 = 0 ;
25298 PyObject *swig_obj[1] ;
25299
25300 if (!args) SWIG_fail;
25301 swig_obj[0] = args;
25302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25303 if (!SWIG_IsOK(res1)) {
25304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25305 }
25306 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 {
25314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25315 }
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25323 PyObject *obj;
25324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25325 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25326 return SWIG_Py_Void();
25327 }
25328
25329 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25330 return SWIG_Python_InitShadowInstance(args);
25331 }
25332
25333 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25334 PyObject *resultobj = 0;
25335 int arg1 = (int) 0 ;
25336 bool arg2 = (bool) true ;
25337 wxIconizeEvent *result = 0 ;
25338 int val1 ;
25339 int ecode1 = 0 ;
25340 bool val2 ;
25341 int ecode2 = 0 ;
25342 PyObject * obj0 = 0 ;
25343 PyObject * obj1 = 0 ;
25344 char * kwnames[] = {
25345 (char *) "id",(char *) "iconized", NULL
25346 };
25347
25348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25349 if (obj0) {
25350 ecode1 = SWIG_AsVal_int(obj0, &val1);
25351 if (!SWIG_IsOK(ecode1)) {
25352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25353 }
25354 arg1 = static_cast< int >(val1);
25355 }
25356 if (obj1) {
25357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25358 if (!SWIG_IsOK(ecode2)) {
25359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25360 }
25361 arg2 = static_cast< bool >(val2);
25362 }
25363 {
25364 PyThreadState* __tstate = wxPyBeginAllowThreads();
25365 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25370 return resultobj;
25371 fail:
25372 return NULL;
25373 }
25374
25375
25376 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25377 PyObject *resultobj = 0;
25378 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25379 bool result;
25380 void *argp1 = 0 ;
25381 int res1 = 0 ;
25382 PyObject *swig_obj[1] ;
25383
25384 if (!args) SWIG_fail;
25385 swig_obj[0] = args;
25386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25387 if (!SWIG_IsOK(res1)) {
25388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25389 }
25390 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25391 {
25392 PyThreadState* __tstate = wxPyBeginAllowThreads();
25393 result = (bool)(arg1)->Iconized();
25394 wxPyEndAllowThreads(__tstate);
25395 if (PyErr_Occurred()) SWIG_fail;
25396 }
25397 {
25398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25399 }
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25407 PyObject *obj;
25408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25409 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25410 return SWIG_Py_Void();
25411 }
25412
25413 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25414 return SWIG_Python_InitShadowInstance(args);
25415 }
25416
25417 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25418 PyObject *resultobj = 0;
25419 int arg1 = (int) 0 ;
25420 wxMaximizeEvent *result = 0 ;
25421 int val1 ;
25422 int ecode1 = 0 ;
25423 PyObject * obj0 = 0 ;
25424 char * kwnames[] = {
25425 (char *) "id", NULL
25426 };
25427
25428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25429 if (obj0) {
25430 ecode1 = SWIG_AsVal_int(obj0, &val1);
25431 if (!SWIG_IsOK(ecode1)) {
25432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25433 }
25434 arg1 = static_cast< int >(val1);
25435 }
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *obj;
25451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25452 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25453 return SWIG_Py_Void();
25454 }
25455
25456 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25457 return SWIG_Python_InitShadowInstance(args);
25458 }
25459
25460 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25461 PyObject *resultobj = 0;
25462 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25463 wxPoint result;
25464 void *argp1 = 0 ;
25465 int res1 = 0 ;
25466 PyObject *swig_obj[1] ;
25467
25468 if (!args) SWIG_fail;
25469 swig_obj[0] = args;
25470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25471 if (!SWIG_IsOK(res1)) {
25472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25473 }
25474 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 result = (arg1)->GetPosition();
25478 wxPyEndAllowThreads(__tstate);
25479 if (PyErr_Occurred()) SWIG_fail;
25480 }
25481 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25489 PyObject *resultobj = 0;
25490 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25491 int result;
25492 void *argp1 = 0 ;
25493 int res1 = 0 ;
25494 PyObject *swig_obj[1] ;
25495
25496 if (!args) SWIG_fail;
25497 swig_obj[0] = args;
25498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25501 }
25502 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 result = (int)(arg1)->GetNumberOfFiles();
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 resultobj = SWIG_From_int(static_cast< int >(result));
25510 return resultobj;
25511 fail:
25512 return NULL;
25513 }
25514
25515
25516 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25517 PyObject *resultobj = 0;
25518 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25519 PyObject *result = 0 ;
25520 void *argp1 = 0 ;
25521 int res1 = 0 ;
25522 PyObject *swig_obj[1] ;
25523
25524 if (!args) SWIG_fail;
25525 swig_obj[0] = args;
25526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25527 if (!SWIG_IsOK(res1)) {
25528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25529 }
25530 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 resultobj = result;
25538 return resultobj;
25539 fail:
25540 return NULL;
25541 }
25542
25543
25544 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25545 PyObject *obj;
25546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25547 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25548 return SWIG_Py_Void();
25549 }
25550
25551 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25552 PyObject *resultobj = 0;
25553 int arg1 = (int) 0 ;
25554 wxUpdateUIEvent *result = 0 ;
25555 int val1 ;
25556 int ecode1 = 0 ;
25557 PyObject * obj0 = 0 ;
25558 char * kwnames[] = {
25559 (char *) "commandId", NULL
25560 };
25561
25562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25563 if (obj0) {
25564 ecode1 = SWIG_AsVal_int(obj0, &val1);
25565 if (!SWIG_IsOK(ecode1)) {
25566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25567 }
25568 arg1 = static_cast< int >(val1);
25569 }
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25586 bool result;
25587 void *argp1 = 0 ;
25588 int res1 = 0 ;
25589 PyObject *swig_obj[1] ;
25590
25591 if (!args) SWIG_fail;
25592 swig_obj[0] = args;
25593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25594 if (!SWIG_IsOK(res1)) {
25595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25596 }
25597 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25598 {
25599 PyThreadState* __tstate = wxPyBeginAllowThreads();
25600 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 {
25605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25606 }
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25614 PyObject *resultobj = 0;
25615 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25616 bool result;
25617 void *argp1 = 0 ;
25618 int res1 = 0 ;
25619 PyObject *swig_obj[1] ;
25620
25621 if (!args) SWIG_fail;
25622 swig_obj[0] = args;
25623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25624 if (!SWIG_IsOK(res1)) {
25625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25626 }
25627 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25628 {
25629 PyThreadState* __tstate = wxPyBeginAllowThreads();
25630 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25644 PyObject *resultobj = 0;
25645 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25646 bool result;
25647 void *argp1 = 0 ;
25648 int res1 = 0 ;
25649 PyObject *swig_obj[1] ;
25650
25651 if (!args) SWIG_fail;
25652 swig_obj[0] = args;
25653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25654 if (!SWIG_IsOK(res1)) {
25655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25656 }
25657 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 {
25665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25666 }
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25674 PyObject *resultobj = 0;
25675 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25676 wxString result;
25677 void *argp1 = 0 ;
25678 int res1 = 0 ;
25679 PyObject *swig_obj[1] ;
25680
25681 if (!args) SWIG_fail;
25682 swig_obj[0] = args;
25683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25684 if (!SWIG_IsOK(res1)) {
25685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25686 }
25687 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 #if wxUSE_UNICODE
25696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25697 #else
25698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25699 #endif
25700 }
25701 return resultobj;
25702 fail:
25703 return NULL;
25704 }
25705
25706
25707 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25708 PyObject *resultobj = 0;
25709 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25710 bool result;
25711 void *argp1 = 0 ;
25712 int res1 = 0 ;
25713 PyObject *swig_obj[1] ;
25714
25715 if (!args) SWIG_fail;
25716 swig_obj[0] = args;
25717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25718 if (!SWIG_IsOK(res1)) {
25719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25720 }
25721 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 {
25729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25730 }
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25738 PyObject *resultobj = 0;
25739 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25740 bool result;
25741 void *argp1 = 0 ;
25742 int res1 = 0 ;
25743 PyObject *swig_obj[1] ;
25744
25745 if (!args) SWIG_fail;
25746 swig_obj[0] = args;
25747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25750 }
25751 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25755 wxPyEndAllowThreads(__tstate);
25756 if (PyErr_Occurred()) SWIG_fail;
25757 }
25758 {
25759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25760 }
25761 return resultobj;
25762 fail:
25763 return NULL;
25764 }
25765
25766
25767 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25768 PyObject *resultobj = 0;
25769 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25770 bool result;
25771 void *argp1 = 0 ;
25772 int res1 = 0 ;
25773 PyObject *swig_obj[1] ;
25774
25775 if (!args) SWIG_fail;
25776 swig_obj[0] = args;
25777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25780 }
25781 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25782 {
25783 PyThreadState* __tstate = wxPyBeginAllowThreads();
25784 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25785 wxPyEndAllowThreads(__tstate);
25786 if (PyErr_Occurred()) SWIG_fail;
25787 }
25788 {
25789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25790 }
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 PyObject *resultobj = 0;
25799 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25800 bool result;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 PyObject *swig_obj[1] ;
25804
25805 if (!args) SWIG_fail;
25806 swig_obj[0] = args;
25807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25810 }
25811 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25830 bool arg2 ;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 bool val2 ;
25834 int ecode2 = 0 ;
25835 PyObject * obj0 = 0 ;
25836 PyObject * obj1 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "self",(char *) "check", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25843 if (!SWIG_IsOK(res1)) {
25844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25845 }
25846 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25848 if (!SWIG_IsOK(ecode2)) {
25849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25850 }
25851 arg2 = static_cast< bool >(val2);
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 (arg1)->Check(arg2);
25855 wxPyEndAllowThreads(__tstate);
25856 if (PyErr_Occurred()) SWIG_fail;
25857 }
25858 resultobj = SWIG_Py_Void();
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj = 0;
25867 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25868 bool arg2 ;
25869 void *argp1 = 0 ;
25870 int res1 = 0 ;
25871 bool val2 ;
25872 int ecode2 = 0 ;
25873 PyObject * obj0 = 0 ;
25874 PyObject * obj1 = 0 ;
25875 char * kwnames[] = {
25876 (char *) "self",(char *) "enable", NULL
25877 };
25878
25879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25881 if (!SWIG_IsOK(res1)) {
25882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25883 }
25884 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25885 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25886 if (!SWIG_IsOK(ecode2)) {
25887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25888 }
25889 arg2 = static_cast< bool >(val2);
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 (arg1)->Enable(arg2);
25893 wxPyEndAllowThreads(__tstate);
25894 if (PyErr_Occurred()) SWIG_fail;
25895 }
25896 resultobj = SWIG_Py_Void();
25897 return resultobj;
25898 fail:
25899 return NULL;
25900 }
25901
25902
25903 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25904 PyObject *resultobj = 0;
25905 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25906 bool arg2 ;
25907 void *argp1 = 0 ;
25908 int res1 = 0 ;
25909 bool val2 ;
25910 int ecode2 = 0 ;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 char * kwnames[] = {
25914 (char *) "self",(char *) "show", NULL
25915 };
25916
25917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25919 if (!SWIG_IsOK(res1)) {
25920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25921 }
25922 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25923 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25924 if (!SWIG_IsOK(ecode2)) {
25925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25926 }
25927 arg2 = static_cast< bool >(val2);
25928 {
25929 PyThreadState* __tstate = wxPyBeginAllowThreads();
25930 (arg1)->Show(arg2);
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 resultobj = SWIG_Py_Void();
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj = 0;
25943 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25944 wxString *arg2 = 0 ;
25945 void *argp1 = 0 ;
25946 int res1 = 0 ;
25947 bool temp2 = false ;
25948 PyObject * obj0 = 0 ;
25949 PyObject * obj1 = 0 ;
25950 char * kwnames[] = {
25951 (char *) "self",(char *) "text", NULL
25952 };
25953
25954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25956 if (!SWIG_IsOK(res1)) {
25957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25958 }
25959 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25960 {
25961 arg2 = wxString_in_helper(obj1);
25962 if (arg2 == NULL) SWIG_fail;
25963 temp2 = true;
25964 }
25965 {
25966 PyThreadState* __tstate = wxPyBeginAllowThreads();
25967 (arg1)->SetText((wxString const &)*arg2);
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 resultobj = SWIG_Py_Void();
25972 {
25973 if (temp2)
25974 delete arg2;
25975 }
25976 return resultobj;
25977 fail:
25978 {
25979 if (temp2)
25980 delete arg2;
25981 }
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj = 0;
25988 long arg1 ;
25989 long val1 ;
25990 int ecode1 = 0 ;
25991 PyObject * obj0 = 0 ;
25992 char * kwnames[] = {
25993 (char *) "updateInterval", NULL
25994 };
25995
25996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25997 ecode1 = SWIG_AsVal_long(obj0, &val1);
25998 if (!SWIG_IsOK(ecode1)) {
25999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26000 }
26001 arg1 = static_cast< long >(val1);
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 wxUpdateUIEvent::SetUpdateInterval(arg1);
26005 wxPyEndAllowThreads(__tstate);
26006 if (PyErr_Occurred()) SWIG_fail;
26007 }
26008 resultobj = SWIG_Py_Void();
26009 return resultobj;
26010 fail:
26011 return NULL;
26012 }
26013
26014
26015 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26016 PyObject *resultobj = 0;
26017 long result;
26018
26019 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26023 wxPyEndAllowThreads(__tstate);
26024 if (PyErr_Occurred()) SWIG_fail;
26025 }
26026 resultobj = SWIG_From_long(static_cast< long >(result));
26027 return resultobj;
26028 fail:
26029 return NULL;
26030 }
26031
26032
26033 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26034 PyObject *resultobj = 0;
26035 wxWindow *arg1 = (wxWindow *) 0 ;
26036 bool result;
26037 void *argp1 = 0 ;
26038 int res1 = 0 ;
26039 PyObject * obj0 = 0 ;
26040 char * kwnames[] = {
26041 (char *) "win", NULL
26042 };
26043
26044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26046 if (!SWIG_IsOK(res1)) {
26047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26048 }
26049 arg1 = reinterpret_cast< wxWindow * >(argp1);
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 {
26057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26058 }
26059 return resultobj;
26060 fail:
26061 return NULL;
26062 }
26063
26064
26065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26066 PyObject *resultobj = 0;
26067
26068 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 wxUpdateUIEvent::ResetUpdateTime();
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 resultobj = SWIG_Py_Void();
26076 return resultobj;
26077 fail:
26078 return NULL;
26079 }
26080
26081
26082 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26083 PyObject *resultobj = 0;
26084 wxUpdateUIMode arg1 ;
26085 int val1 ;
26086 int ecode1 = 0 ;
26087 PyObject * obj0 = 0 ;
26088 char * kwnames[] = {
26089 (char *) "mode", NULL
26090 };
26091
26092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26093 ecode1 = SWIG_AsVal_int(obj0, &val1);
26094 if (!SWIG_IsOK(ecode1)) {
26095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26096 }
26097 arg1 = static_cast< wxUpdateUIMode >(val1);
26098 {
26099 PyThreadState* __tstate = wxPyBeginAllowThreads();
26100 wxUpdateUIEvent::SetMode(arg1);
26101 wxPyEndAllowThreads(__tstate);
26102 if (PyErr_Occurred()) SWIG_fail;
26103 }
26104 resultobj = SWIG_Py_Void();
26105 return resultobj;
26106 fail:
26107 return NULL;
26108 }
26109
26110
26111 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26112 PyObject *resultobj = 0;
26113 wxUpdateUIMode result;
26114
26115 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_From_int(static_cast< int >(result));
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *obj;
26131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26132 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26133 return SWIG_Py_Void();
26134 }
26135
26136 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26137 return SWIG_Python_InitShadowInstance(args);
26138 }
26139
26140 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26141 PyObject *resultobj = 0;
26142 wxSysColourChangedEvent *result = 0 ;
26143
26144 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26152 return resultobj;
26153 fail:
26154 return NULL;
26155 }
26156
26157
26158 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26159 PyObject *obj;
26160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26161 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26162 return SWIG_Py_Void();
26163 }
26164
26165 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26166 return SWIG_Python_InitShadowInstance(args);
26167 }
26168
26169 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj = 0;
26171 int arg1 = (int) 0 ;
26172 wxWindow *arg2 = (wxWindow *) NULL ;
26173 wxMouseCaptureChangedEvent *result = 0 ;
26174 int val1 ;
26175 int ecode1 = 0 ;
26176 void *argp2 = 0 ;
26177 int res2 = 0 ;
26178 PyObject * obj0 = 0 ;
26179 PyObject * obj1 = 0 ;
26180 char * kwnames[] = {
26181 (char *) "winid",(char *) "gainedCapture", NULL
26182 };
26183
26184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26185 if (obj0) {
26186 ecode1 = SWIG_AsVal_int(obj0, &val1);
26187 if (!SWIG_IsOK(ecode1)) {
26188 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26189 }
26190 arg1 = static_cast< int >(val1);
26191 }
26192 if (obj1) {
26193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26194 if (!SWIG_IsOK(res2)) {
26195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26196 }
26197 arg2 = reinterpret_cast< wxWindow * >(argp2);
26198 }
26199 {
26200 PyThreadState* __tstate = wxPyBeginAllowThreads();
26201 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26202 wxPyEndAllowThreads(__tstate);
26203 if (PyErr_Occurred()) SWIG_fail;
26204 }
26205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26206 return resultobj;
26207 fail:
26208 return NULL;
26209 }
26210
26211
26212 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26213 PyObject *resultobj = 0;
26214 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26215 wxWindow *result = 0 ;
26216 void *argp1 = 0 ;
26217 int res1 = 0 ;
26218 PyObject *swig_obj[1] ;
26219
26220 if (!args) SWIG_fail;
26221 swig_obj[0] = args;
26222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26223 if (!SWIG_IsOK(res1)) {
26224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26225 }
26226 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26227 {
26228 PyThreadState* __tstate = wxPyBeginAllowThreads();
26229 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26230 wxPyEndAllowThreads(__tstate);
26231 if (PyErr_Occurred()) SWIG_fail;
26232 }
26233 {
26234 resultobj = wxPyMake_wxObject(result, (bool)0);
26235 }
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26243 PyObject *obj;
26244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26245 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26246 return SWIG_Py_Void();
26247 }
26248
26249 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26250 return SWIG_Python_InitShadowInstance(args);
26251 }
26252
26253 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26254 PyObject *resultobj = 0;
26255 int arg1 = (int) 0 ;
26256 wxMouseCaptureLostEvent *result = 0 ;
26257 int val1 ;
26258 int ecode1 = 0 ;
26259 PyObject * obj0 = 0 ;
26260 char * kwnames[] = {
26261 (char *) "winid", NULL
26262 };
26263
26264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26265 if (obj0) {
26266 ecode1 = SWIG_AsVal_int(obj0, &val1);
26267 if (!SWIG_IsOK(ecode1)) {
26268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26269 }
26270 arg1 = static_cast< int >(val1);
26271 }
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 PyObject *obj;
26287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26288 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26289 return SWIG_Py_Void();
26290 }
26291
26292 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26293 return SWIG_Python_InitShadowInstance(args);
26294 }
26295
26296 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *resultobj = 0;
26298 wxDisplayChangedEvent *result = 0 ;
26299
26300 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26301 {
26302 PyThreadState* __tstate = wxPyBeginAllowThreads();
26303 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26308 return resultobj;
26309 fail:
26310 return NULL;
26311 }
26312
26313
26314 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26315 PyObject *obj;
26316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26317 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26318 return SWIG_Py_Void();
26319 }
26320
26321 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26322 return SWIG_Python_InitShadowInstance(args);
26323 }
26324
26325 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = 0;
26327 int arg1 = (int) 0 ;
26328 wxPaletteChangedEvent *result = 0 ;
26329 int val1 ;
26330 int ecode1 = 0 ;
26331 PyObject * obj0 = 0 ;
26332 char * kwnames[] = {
26333 (char *) "id", NULL
26334 };
26335
26336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26337 if (obj0) {
26338 ecode1 = SWIG_AsVal_int(obj0, &val1);
26339 if (!SWIG_IsOK(ecode1)) {
26340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26341 }
26342 arg1 = static_cast< int >(val1);
26343 }
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26347 wxPyEndAllowThreads(__tstate);
26348 if (PyErr_Occurred()) SWIG_fail;
26349 }
26350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26351 return resultobj;
26352 fail:
26353 return NULL;
26354 }
26355
26356
26357 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26358 PyObject *resultobj = 0;
26359 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26360 wxWindow *arg2 = (wxWindow *) 0 ;
26361 void *argp1 = 0 ;
26362 int res1 = 0 ;
26363 void *argp2 = 0 ;
26364 int res2 = 0 ;
26365 PyObject * obj0 = 0 ;
26366 PyObject * obj1 = 0 ;
26367 char * kwnames[] = {
26368 (char *) "self",(char *) "win", NULL
26369 };
26370
26371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26375 }
26376 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26378 if (!SWIG_IsOK(res2)) {
26379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26380 }
26381 arg2 = reinterpret_cast< wxWindow * >(argp2);
26382 {
26383 PyThreadState* __tstate = wxPyBeginAllowThreads();
26384 (arg1)->SetChangedWindow(arg2);
26385 wxPyEndAllowThreads(__tstate);
26386 if (PyErr_Occurred()) SWIG_fail;
26387 }
26388 resultobj = SWIG_Py_Void();
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26396 PyObject *resultobj = 0;
26397 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26398 wxWindow *result = 0 ;
26399 void *argp1 = 0 ;
26400 int res1 = 0 ;
26401 PyObject *swig_obj[1] ;
26402
26403 if (!args) SWIG_fail;
26404 swig_obj[0] = args;
26405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26406 if (!SWIG_IsOK(res1)) {
26407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26408 }
26409 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = (wxWindow *)(arg1)->GetChangedWindow();
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 {
26417 resultobj = wxPyMake_wxObject(result, (bool)0);
26418 }
26419 return resultobj;
26420 fail:
26421 return NULL;
26422 }
26423
26424
26425 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26426 PyObject *obj;
26427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26428 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26429 return SWIG_Py_Void();
26430 }
26431
26432 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26433 return SWIG_Python_InitShadowInstance(args);
26434 }
26435
26436 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26437 PyObject *resultobj = 0;
26438 int arg1 = (int) 0 ;
26439 wxQueryNewPaletteEvent *result = 0 ;
26440 int val1 ;
26441 int ecode1 = 0 ;
26442 PyObject * obj0 = 0 ;
26443 char * kwnames[] = {
26444 (char *) "winid", NULL
26445 };
26446
26447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26448 if (obj0) {
26449 ecode1 = SWIG_AsVal_int(obj0, &val1);
26450 if (!SWIG_IsOK(ecode1)) {
26451 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26452 }
26453 arg1 = static_cast< int >(val1);
26454 }
26455 {
26456 PyThreadState* __tstate = wxPyBeginAllowThreads();
26457 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26458 wxPyEndAllowThreads(__tstate);
26459 if (PyErr_Occurred()) SWIG_fail;
26460 }
26461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26462 return resultobj;
26463 fail:
26464 return NULL;
26465 }
26466
26467
26468 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26469 PyObject *resultobj = 0;
26470 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26471 bool arg2 ;
26472 void *argp1 = 0 ;
26473 int res1 = 0 ;
26474 bool val2 ;
26475 int ecode2 = 0 ;
26476 PyObject * obj0 = 0 ;
26477 PyObject * obj1 = 0 ;
26478 char * kwnames[] = {
26479 (char *) "self",(char *) "realized", NULL
26480 };
26481
26482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26484 if (!SWIG_IsOK(res1)) {
26485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26486 }
26487 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26488 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26489 if (!SWIG_IsOK(ecode2)) {
26490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26491 }
26492 arg2 = static_cast< bool >(val2);
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 (arg1)->SetPaletteRealized(arg2);
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_Py_Void();
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26507 PyObject *resultobj = 0;
26508 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26509 bool result;
26510 void *argp1 = 0 ;
26511 int res1 = 0 ;
26512 PyObject *swig_obj[1] ;
26513
26514 if (!args) SWIG_fail;
26515 swig_obj[0] = args;
26516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26517 if (!SWIG_IsOK(res1)) {
26518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26519 }
26520 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26521 {
26522 PyThreadState* __tstate = wxPyBeginAllowThreads();
26523 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 {
26528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26529 }
26530 return resultobj;
26531 fail:
26532 return NULL;
26533 }
26534
26535
26536 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26537 PyObject *obj;
26538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26539 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26540 return SWIG_Py_Void();
26541 }
26542
26543 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26544 return SWIG_Python_InitShadowInstance(args);
26545 }
26546
26547 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *resultobj = 0;
26549 wxNavigationKeyEvent *result = 0 ;
26550
26551 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 PyObject *resultobj = 0;
26567 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26568 bool result;
26569 void *argp1 = 0 ;
26570 int res1 = 0 ;
26571 PyObject *swig_obj[1] ;
26572
26573 if (!args) SWIG_fail;
26574 swig_obj[0] = args;
26575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26576 if (!SWIG_IsOK(res1)) {
26577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26578 }
26579 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26580 {
26581 PyThreadState* __tstate = wxPyBeginAllowThreads();
26582 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26583 wxPyEndAllowThreads(__tstate);
26584 if (PyErr_Occurred()) SWIG_fail;
26585 }
26586 {
26587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26588 }
26589 return resultobj;
26590 fail:
26591 return NULL;
26592 }
26593
26594
26595 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26596 PyObject *resultobj = 0;
26597 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26598 bool arg2 ;
26599 void *argp1 = 0 ;
26600 int res1 = 0 ;
26601 bool val2 ;
26602 int ecode2 = 0 ;
26603 PyObject * obj0 = 0 ;
26604 PyObject * obj1 = 0 ;
26605 char * kwnames[] = {
26606 (char *) "self",(char *) "forward", NULL
26607 };
26608
26609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26611 if (!SWIG_IsOK(res1)) {
26612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26613 }
26614 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26616 if (!SWIG_IsOK(ecode2)) {
26617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26618 }
26619 arg2 = static_cast< bool >(val2);
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 (arg1)->SetDirection(arg2);
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 resultobj = SWIG_Py_Void();
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26634 PyObject *resultobj = 0;
26635 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26636 bool result;
26637 void *argp1 = 0 ;
26638 int res1 = 0 ;
26639 PyObject *swig_obj[1] ;
26640
26641 if (!args) SWIG_fail;
26642 swig_obj[0] = args;
26643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26644 if (!SWIG_IsOK(res1)) {
26645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26646 }
26647 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26651 wxPyEndAllowThreads(__tstate);
26652 if (PyErr_Occurred()) SWIG_fail;
26653 }
26654 {
26655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26656 }
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = 0;
26665 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26666 bool arg2 ;
26667 void *argp1 = 0 ;
26668 int res1 = 0 ;
26669 bool val2 ;
26670 int ecode2 = 0 ;
26671 PyObject * obj0 = 0 ;
26672 PyObject * obj1 = 0 ;
26673 char * kwnames[] = {
26674 (char *) "self",(char *) "ischange", NULL
26675 };
26676
26677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26679 if (!SWIG_IsOK(res1)) {
26680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26681 }
26682 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26684 if (!SWIG_IsOK(ecode2)) {
26685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26686 }
26687 arg2 = static_cast< bool >(val2);
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 (arg1)->SetWindowChange(arg2);
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 resultobj = SWIG_Py_Void();
26695 return resultobj;
26696 fail:
26697 return NULL;
26698 }
26699
26700
26701 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 PyObject *resultobj = 0;
26703 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26704 bool result;
26705 void *argp1 = 0 ;
26706 int res1 = 0 ;
26707 PyObject *swig_obj[1] ;
26708
26709 if (!args) SWIG_fail;
26710 swig_obj[0] = args;
26711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26714 }
26715 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26716 {
26717 PyThreadState* __tstate = wxPyBeginAllowThreads();
26718 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj = 0;
26733 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26734 bool arg2 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 bool val2 ;
26738 int ecode2 = 0 ;
26739 PyObject * obj0 = 0 ;
26740 PyObject * obj1 = 0 ;
26741 char * kwnames[] = {
26742 (char *) "self",(char *) "bIs", NULL
26743 };
26744
26745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26747 if (!SWIG_IsOK(res1)) {
26748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26749 }
26750 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26751 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26752 if (!SWIG_IsOK(ecode2)) {
26753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26754 }
26755 arg2 = static_cast< bool >(val2);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->SetFromTab(arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_Py_Void();
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26772 long arg2 ;
26773 void *argp1 = 0 ;
26774 int res1 = 0 ;
26775 long val2 ;
26776 int ecode2 = 0 ;
26777 PyObject * obj0 = 0 ;
26778 PyObject * obj1 = 0 ;
26779 char * kwnames[] = {
26780 (char *) "self",(char *) "flags", NULL
26781 };
26782
26783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26785 if (!SWIG_IsOK(res1)) {
26786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26787 }
26788 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26789 ecode2 = SWIG_AsVal_long(obj1, &val2);
26790 if (!SWIG_IsOK(ecode2)) {
26791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26792 }
26793 arg2 = static_cast< long >(val2);
26794 {
26795 PyThreadState* __tstate = wxPyBeginAllowThreads();
26796 (arg1)->SetFlags(arg2);
26797 wxPyEndAllowThreads(__tstate);
26798 if (PyErr_Occurred()) SWIG_fail;
26799 }
26800 resultobj = SWIG_Py_Void();
26801 return resultobj;
26802 fail:
26803 return NULL;
26804 }
26805
26806
26807 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26808 PyObject *resultobj = 0;
26809 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26810 wxWindow *result = 0 ;
26811 void *argp1 = 0 ;
26812 int res1 = 0 ;
26813 PyObject *swig_obj[1] ;
26814
26815 if (!args) SWIG_fail;
26816 swig_obj[0] = args;
26817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26818 if (!SWIG_IsOK(res1)) {
26819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26820 }
26821 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26822 {
26823 PyThreadState* __tstate = wxPyBeginAllowThreads();
26824 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26825 wxPyEndAllowThreads(__tstate);
26826 if (PyErr_Occurred()) SWIG_fail;
26827 }
26828 {
26829 resultobj = wxPyMake_wxObject(result, (bool)0);
26830 }
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26838 PyObject *resultobj = 0;
26839 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26840 wxWindow *arg2 = (wxWindow *) 0 ;
26841 void *argp1 = 0 ;
26842 int res1 = 0 ;
26843 void *argp2 = 0 ;
26844 int res2 = 0 ;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char * kwnames[] = {
26848 (char *) "self",(char *) "win", NULL
26849 };
26850
26851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26853 if (!SWIG_IsOK(res1)) {
26854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26855 }
26856 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26858 if (!SWIG_IsOK(res2)) {
26859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26860 }
26861 arg2 = reinterpret_cast< wxWindow * >(argp2);
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 (arg1)->SetCurrentFocus(arg2);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 resultobj = SWIG_Py_Void();
26869 return resultobj;
26870 fail:
26871 return NULL;
26872 }
26873
26874
26875 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26876 PyObject *obj;
26877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26878 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26879 return SWIG_Py_Void();
26880 }
26881
26882 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 return SWIG_Python_InitShadowInstance(args);
26884 }
26885
26886 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26887 PyObject *resultobj = 0;
26888 wxWindow *arg1 = (wxWindow *) NULL ;
26889 wxWindowCreateEvent *result = 0 ;
26890 void *argp1 = 0 ;
26891 int res1 = 0 ;
26892 PyObject * obj0 = 0 ;
26893 char * kwnames[] = {
26894 (char *) "win", NULL
26895 };
26896
26897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26898 if (obj0) {
26899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26900 if (!SWIG_IsOK(res1)) {
26901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26902 }
26903 arg1 = reinterpret_cast< wxWindow * >(argp1);
26904 }
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26912 return resultobj;
26913 fail:
26914 return NULL;
26915 }
26916
26917
26918 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26919 PyObject *resultobj = 0;
26920 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26921 wxWindow *result = 0 ;
26922 void *argp1 = 0 ;
26923 int res1 = 0 ;
26924 PyObject *swig_obj[1] ;
26925
26926 if (!args) SWIG_fail;
26927 swig_obj[0] = args;
26928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26929 if (!SWIG_IsOK(res1)) {
26930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26931 }
26932 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26933 {
26934 PyThreadState* __tstate = wxPyBeginAllowThreads();
26935 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26936 wxPyEndAllowThreads(__tstate);
26937 if (PyErr_Occurred()) SWIG_fail;
26938 }
26939 {
26940 resultobj = wxPyMake_wxObject(result, (bool)0);
26941 }
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26949 PyObject *obj;
26950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26951 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26952 return SWIG_Py_Void();
26953 }
26954
26955 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26956 return SWIG_Python_InitShadowInstance(args);
26957 }
26958
26959 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26960 PyObject *resultobj = 0;
26961 wxWindow *arg1 = (wxWindow *) NULL ;
26962 wxWindowDestroyEvent *result = 0 ;
26963 void *argp1 = 0 ;
26964 int res1 = 0 ;
26965 PyObject * obj0 = 0 ;
26966 char * kwnames[] = {
26967 (char *) "win", NULL
26968 };
26969
26970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26971 if (obj0) {
26972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26975 }
26976 arg1 = reinterpret_cast< wxWindow * >(argp1);
26977 }
26978 {
26979 PyThreadState* __tstate = wxPyBeginAllowThreads();
26980 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26981 wxPyEndAllowThreads(__tstate);
26982 if (PyErr_Occurred()) SWIG_fail;
26983 }
26984 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26985 return resultobj;
26986 fail:
26987 return NULL;
26988 }
26989
26990
26991 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26992 PyObject *resultobj = 0;
26993 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26994 wxWindow *result = 0 ;
26995 void *argp1 = 0 ;
26996 int res1 = 0 ;
26997 PyObject *swig_obj[1] ;
26998
26999 if (!args) SWIG_fail;
27000 swig_obj[0] = args;
27001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27002 if (!SWIG_IsOK(res1)) {
27003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27004 }
27005 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27006 {
27007 PyThreadState* __tstate = wxPyBeginAllowThreads();
27008 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27009 wxPyEndAllowThreads(__tstate);
27010 if (PyErr_Occurred()) SWIG_fail;
27011 }
27012 {
27013 resultobj = wxPyMake_wxObject(result, (bool)0);
27014 }
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27022 PyObject *obj;
27023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27024 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27025 return SWIG_Py_Void();
27026 }
27027
27028 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27029 return SWIG_Python_InitShadowInstance(args);
27030 }
27031
27032 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj = 0;
27034 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27035 int arg2 = (int) 0 ;
27036 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27037 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27038 wxContextMenuEvent *result = 0 ;
27039 int val1 ;
27040 int ecode1 = 0 ;
27041 int val2 ;
27042 int ecode2 = 0 ;
27043 wxPoint temp3 ;
27044 PyObject * obj0 = 0 ;
27045 PyObject * obj1 = 0 ;
27046 PyObject * obj2 = 0 ;
27047 char * kwnames[] = {
27048 (char *) "type",(char *) "winid",(char *) "pt", NULL
27049 };
27050
27051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27052 if (obj0) {
27053 ecode1 = SWIG_AsVal_int(obj0, &val1);
27054 if (!SWIG_IsOK(ecode1)) {
27055 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27056 }
27057 arg1 = static_cast< wxEventType >(val1);
27058 }
27059 if (obj1) {
27060 ecode2 = SWIG_AsVal_int(obj1, &val2);
27061 if (!SWIG_IsOK(ecode2)) {
27062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27063 }
27064 arg2 = static_cast< int >(val2);
27065 }
27066 if (obj2) {
27067 {
27068 arg3 = &temp3;
27069 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27070 }
27071 }
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27075 wxPyEndAllowThreads(__tstate);
27076 if (PyErr_Occurred()) SWIG_fail;
27077 }
27078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27079 return resultobj;
27080 fail:
27081 return NULL;
27082 }
27083
27084
27085 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27086 PyObject *resultobj = 0;
27087 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27088 wxPoint *result = 0 ;
27089 void *argp1 = 0 ;
27090 int res1 = 0 ;
27091 PyObject *swig_obj[1] ;
27092
27093 if (!args) SWIG_fail;
27094 swig_obj[0] = args;
27095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27096 if (!SWIG_IsOK(res1)) {
27097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27098 }
27099 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27100 {
27101 PyThreadState* __tstate = wxPyBeginAllowThreads();
27102 {
27103 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27104 result = (wxPoint *) &_result_ref;
27105 }
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27117 PyObject *resultobj = 0;
27118 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27119 wxPoint *arg2 = 0 ;
27120 void *argp1 = 0 ;
27121 int res1 = 0 ;
27122 wxPoint temp2 ;
27123 PyObject * obj0 = 0 ;
27124 PyObject * obj1 = 0 ;
27125 char * kwnames[] = {
27126 (char *) "self",(char *) "pos", NULL
27127 };
27128
27129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27131 if (!SWIG_IsOK(res1)) {
27132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27133 }
27134 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27135 {
27136 arg2 = &temp2;
27137 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27138 }
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 (arg1)->SetPosition((wxPoint const &)*arg2);
27142 wxPyEndAllowThreads(__tstate);
27143 if (PyErr_Occurred()) SWIG_fail;
27144 }
27145 resultobj = SWIG_Py_Void();
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27153 PyObject *obj;
27154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27155 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27156 return SWIG_Py_Void();
27157 }
27158
27159 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27160 return SWIG_Python_InitShadowInstance(args);
27161 }
27162
27163 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 PyObject *resultobj = 0;
27165 wxIdleEvent *result = 0 ;
27166
27167 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (wxIdleEvent *)new wxIdleEvent();
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27182 PyObject *resultobj = 0;
27183 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27184 bool arg2 = (bool) true ;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 bool val2 ;
27188 int ecode2 = 0 ;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char * kwnames[] = {
27192 (char *) "self",(char *) "needMore", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27197 if (!SWIG_IsOK(res1)) {
27198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27199 }
27200 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27201 if (obj1) {
27202 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27203 if (!SWIG_IsOK(ecode2)) {
27204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27205 }
27206 arg2 = static_cast< bool >(val2);
27207 }
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 (arg1)->RequestMore(arg2);
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 resultobj = SWIG_Py_Void();
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27222 PyObject *resultobj = 0;
27223 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27224 bool result;
27225 void *argp1 = 0 ;
27226 int res1 = 0 ;
27227 PyObject *swig_obj[1] ;
27228
27229 if (!args) SWIG_fail;
27230 swig_obj[0] = args;
27231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27232 if (!SWIG_IsOK(res1)) {
27233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27234 }
27235 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 {
27243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27244 }
27245 return resultobj;
27246 fail:
27247 return NULL;
27248 }
27249
27250
27251 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27252 PyObject *resultobj = 0;
27253 wxIdleMode arg1 ;
27254 int val1 ;
27255 int ecode1 = 0 ;
27256 PyObject * obj0 = 0 ;
27257 char * kwnames[] = {
27258 (char *) "mode", NULL
27259 };
27260
27261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27262 ecode1 = SWIG_AsVal_int(obj0, &val1);
27263 if (!SWIG_IsOK(ecode1)) {
27264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27265 }
27266 arg1 = static_cast< wxIdleMode >(val1);
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 wxIdleEvent::SetMode(arg1);
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 resultobj = SWIG_Py_Void();
27274 return resultobj;
27275 fail:
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27281 PyObject *resultobj = 0;
27282 wxIdleMode result;
27283
27284 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = (wxIdleMode)wxIdleEvent::GetMode();
27288 wxPyEndAllowThreads(__tstate);
27289 if (PyErr_Occurred()) SWIG_fail;
27290 }
27291 resultobj = SWIG_From_int(static_cast< int >(result));
27292 return resultobj;
27293 fail:
27294 return NULL;
27295 }
27296
27297
27298 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27299 PyObject *resultobj = 0;
27300 wxWindow *arg1 = (wxWindow *) 0 ;
27301 bool result;
27302 void *argp1 = 0 ;
27303 int res1 = 0 ;
27304 PyObject * obj0 = 0 ;
27305 char * kwnames[] = {
27306 (char *) "win", NULL
27307 };
27308
27309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27311 if (!SWIG_IsOK(res1)) {
27312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27313 }
27314 arg1 = reinterpret_cast< wxWindow * >(argp1);
27315 {
27316 PyThreadState* __tstate = wxPyBeginAllowThreads();
27317 result = (bool)wxIdleEvent::CanSend(arg1);
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 {
27322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27323 }
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27331 PyObject *obj;
27332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27333 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27334 return SWIG_Py_Void();
27335 }
27336
27337 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27338 return SWIG_Python_InitShadowInstance(args);
27339 }
27340
27341 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj = 0;
27343 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27344 int arg2 = (int) 0 ;
27345 wxClipboardTextEvent *result = 0 ;
27346 int val1 ;
27347 int ecode1 = 0 ;
27348 int val2 ;
27349 int ecode2 = 0 ;
27350 PyObject * obj0 = 0 ;
27351 PyObject * obj1 = 0 ;
27352 char * kwnames[] = {
27353 (char *) "type",(char *) "winid", NULL
27354 };
27355
27356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27357 if (obj0) {
27358 ecode1 = SWIG_AsVal_int(obj0, &val1);
27359 if (!SWIG_IsOK(ecode1)) {
27360 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27361 }
27362 arg1 = static_cast< wxEventType >(val1);
27363 }
27364 if (obj1) {
27365 ecode2 = SWIG_AsVal_int(obj1, &val2);
27366 if (!SWIG_IsOK(ecode2)) {
27367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27368 }
27369 arg2 = static_cast< int >(val2);
27370 }
27371 {
27372 PyThreadState* __tstate = wxPyBeginAllowThreads();
27373 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27378 return resultobj;
27379 fail:
27380 return NULL;
27381 }
27382
27383
27384 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27385 PyObject *obj;
27386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27387 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27388 return SWIG_Py_Void();
27389 }
27390
27391 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27392 return SWIG_Python_InitShadowInstance(args);
27393 }
27394
27395 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27396 PyObject *resultobj = 0;
27397 int arg1 = (int) 0 ;
27398 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27399 wxPyEvent *result = 0 ;
27400 int val1 ;
27401 int ecode1 = 0 ;
27402 int val2 ;
27403 int ecode2 = 0 ;
27404 PyObject * obj0 = 0 ;
27405 PyObject * obj1 = 0 ;
27406 char * kwnames[] = {
27407 (char *) "winid",(char *) "eventType", NULL
27408 };
27409
27410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27411 if (obj0) {
27412 ecode1 = SWIG_AsVal_int(obj0, &val1);
27413 if (!SWIG_IsOK(ecode1)) {
27414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27415 }
27416 arg1 = static_cast< int >(val1);
27417 }
27418 if (obj1) {
27419 ecode2 = SWIG_AsVal_int(obj1, &val2);
27420 if (!SWIG_IsOK(ecode2)) {
27421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27422 }
27423 arg2 = static_cast< wxEventType >(val2);
27424 }
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27428 wxPyEndAllowThreads(__tstate);
27429 if (PyErr_Occurred()) SWIG_fail;
27430 }
27431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27432 return resultobj;
27433 fail:
27434 return NULL;
27435 }
27436
27437
27438 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27439 PyObject *resultobj = 0;
27440 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27441 void *argp1 = 0 ;
27442 int res1 = 0 ;
27443 PyObject *swig_obj[1] ;
27444
27445 if (!args) SWIG_fail;
27446 swig_obj[0] = args;
27447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27450 }
27451 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 delete arg1;
27455
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 resultobj = SWIG_Py_Void();
27460 return resultobj;
27461 fail:
27462 return NULL;
27463 }
27464
27465
27466 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27467 PyObject *resultobj = 0;
27468 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27469 PyObject *arg2 = (PyObject *) 0 ;
27470 void *argp1 = 0 ;
27471 int res1 = 0 ;
27472 PyObject * obj0 = 0 ;
27473 PyObject * obj1 = 0 ;
27474 char * kwnames[] = {
27475 (char *) "self",(char *) "self", NULL
27476 };
27477
27478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27480 if (!SWIG_IsOK(res1)) {
27481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27482 }
27483 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27484 arg2 = obj1;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 (arg1)->SetSelf(arg2);
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 resultobj = SWIG_Py_Void();
27492 return resultobj;
27493 fail:
27494 return NULL;
27495 }
27496
27497
27498 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27499 PyObject *resultobj = 0;
27500 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27501 PyObject *result = 0 ;
27502 void *argp1 = 0 ;
27503 int res1 = 0 ;
27504 PyObject *swig_obj[1] ;
27505
27506 if (!args) SWIG_fail;
27507 swig_obj[0] = args;
27508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27509 if (!SWIG_IsOK(res1)) {
27510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27511 }
27512 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27513 {
27514 PyThreadState* __tstate = wxPyBeginAllowThreads();
27515 result = (PyObject *)(arg1)->GetSelf();
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 resultobj = result;
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *obj;
27528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27529 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27530 return SWIG_Py_Void();
27531 }
27532
27533 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27534 return SWIG_Python_InitShadowInstance(args);
27535 }
27536
27537 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = 0;
27539 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27540 int arg2 = (int) 0 ;
27541 wxPyCommandEvent *result = 0 ;
27542 int val1 ;
27543 int ecode1 = 0 ;
27544 int val2 ;
27545 int ecode2 = 0 ;
27546 PyObject * obj0 = 0 ;
27547 PyObject * obj1 = 0 ;
27548 char * kwnames[] = {
27549 (char *) "eventType",(char *) "id", NULL
27550 };
27551
27552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27553 if (obj0) {
27554 ecode1 = SWIG_AsVal_int(obj0, &val1);
27555 if (!SWIG_IsOK(ecode1)) {
27556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27557 }
27558 arg1 = static_cast< wxEventType >(val1);
27559 }
27560 if (obj1) {
27561 ecode2 = SWIG_AsVal_int(obj1, &val2);
27562 if (!SWIG_IsOK(ecode2)) {
27563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27564 }
27565 arg2 = static_cast< int >(val2);
27566 }
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27574 return resultobj;
27575 fail:
27576 return NULL;
27577 }
27578
27579
27580 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27581 PyObject *resultobj = 0;
27582 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27583 void *argp1 = 0 ;
27584 int res1 = 0 ;
27585 PyObject *swig_obj[1] ;
27586
27587 if (!args) SWIG_fail;
27588 swig_obj[0] = args;
27589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27590 if (!SWIG_IsOK(res1)) {
27591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27592 }
27593 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 delete arg1;
27597
27598 wxPyEndAllowThreads(__tstate);
27599 if (PyErr_Occurred()) SWIG_fail;
27600 }
27601 resultobj = SWIG_Py_Void();
27602 return resultobj;
27603 fail:
27604 return NULL;
27605 }
27606
27607
27608 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27609 PyObject *resultobj = 0;
27610 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27611 PyObject *arg2 = (PyObject *) 0 ;
27612 void *argp1 = 0 ;
27613 int res1 = 0 ;
27614 PyObject * obj0 = 0 ;
27615 PyObject * obj1 = 0 ;
27616 char * kwnames[] = {
27617 (char *) "self",(char *) "self", NULL
27618 };
27619
27620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27624 }
27625 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27626 arg2 = obj1;
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 (arg1)->SetSelf(arg2);
27630 wxPyEndAllowThreads(__tstate);
27631 if (PyErr_Occurred()) SWIG_fail;
27632 }
27633 resultobj = SWIG_Py_Void();
27634 return resultobj;
27635 fail:
27636 return NULL;
27637 }
27638
27639
27640 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27641 PyObject *resultobj = 0;
27642 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27643 PyObject *result = 0 ;
27644 void *argp1 = 0 ;
27645 int res1 = 0 ;
27646 PyObject *swig_obj[1] ;
27647
27648 if (!args) SWIG_fail;
27649 swig_obj[0] = args;
27650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27651 if (!SWIG_IsOK(res1)) {
27652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27653 }
27654 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (PyObject *)(arg1)->GetSelf();
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 resultobj = result;
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27669 PyObject *obj;
27670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27672 return SWIG_Py_Void();
27673 }
27674
27675 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27676 return SWIG_Python_InitShadowInstance(args);
27677 }
27678
27679 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj = 0;
27681 wxWindow *arg1 = (wxWindow *) 0 ;
27682 wxDateTime *arg2 = 0 ;
27683 wxEventType arg3 ;
27684 wxDateEvent *result = 0 ;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 void *argp2 = 0 ;
27688 int res2 = 0 ;
27689 int val3 ;
27690 int ecode3 = 0 ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 PyObject * obj2 = 0 ;
27694 char * kwnames[] = {
27695 (char *) "win",(char *) "dt",(char *) "type", NULL
27696 };
27697
27698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27700 if (!SWIG_IsOK(res1)) {
27701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27702 }
27703 arg1 = reinterpret_cast< wxWindow * >(argp1);
27704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27705 if (!SWIG_IsOK(res2)) {
27706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27707 }
27708 if (!argp2) {
27709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27710 }
27711 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27712 ecode3 = SWIG_AsVal_int(obj2, &val3);
27713 if (!SWIG_IsOK(ecode3)) {
27714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27715 }
27716 arg3 = static_cast< wxEventType >(val3);
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27724 return resultobj;
27725 fail:
27726 return NULL;
27727 }
27728
27729
27730 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27731 PyObject *resultobj = 0;
27732 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27733 wxDateTime *result = 0 ;
27734 void *argp1 = 0 ;
27735 int res1 = 0 ;
27736 PyObject *swig_obj[1] ;
27737
27738 if (!args) SWIG_fail;
27739 swig_obj[0] = args;
27740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27743 }
27744 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27745 {
27746 PyThreadState* __tstate = wxPyBeginAllowThreads();
27747 {
27748 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27749 result = (wxDateTime *) &_result_ref;
27750 }
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27762 PyObject *resultobj = 0;
27763 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27764 wxDateTime *arg2 = 0 ;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 void *argp2 = 0 ;
27768 int res2 = 0 ;
27769 PyObject * obj0 = 0 ;
27770 PyObject * obj1 = 0 ;
27771 char * kwnames[] = {
27772 (char *) "self",(char *) "date", NULL
27773 };
27774
27775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27777 if (!SWIG_IsOK(res1)) {
27778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27779 }
27780 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27781 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27782 if (!SWIG_IsOK(res2)) {
27783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27784 }
27785 if (!argp2) {
27786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27787 }
27788 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27789 {
27790 PyThreadState* __tstate = wxPyBeginAllowThreads();
27791 (arg1)->SetDate((wxDateTime const &)*arg2);
27792 wxPyEndAllowThreads(__tstate);
27793 if (PyErr_Occurred()) SWIG_fail;
27794 }
27795 resultobj = SWIG_Py_Void();
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27803 PyObject *obj;
27804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27805 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27806 return SWIG_Py_Void();
27807 }
27808
27809 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27810 return SWIG_Python_InitShadowInstance(args);
27811 }
27812
27813 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27814 PyObject *resultobj = 0;
27815 wxPyApp *result = 0 ;
27816
27817 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27818 {
27819 PyThreadState* __tstate = wxPyBeginAllowThreads();
27820 result = (wxPyApp *)new_wxPyApp();
27821 wxPyEndAllowThreads(__tstate);
27822 if (PyErr_Occurred()) SWIG_fail;
27823 }
27824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27825 return resultobj;
27826 fail:
27827 return NULL;
27828 }
27829
27830
27831 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27832 PyObject *resultobj = 0;
27833 wxPyApp *arg1 = (wxPyApp *) 0 ;
27834 void *argp1 = 0 ;
27835 int res1 = 0 ;
27836 PyObject *swig_obj[1] ;
27837
27838 if (!args) SWIG_fail;
27839 swig_obj[0] = args;
27840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27841 if (!SWIG_IsOK(res1)) {
27842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27843 }
27844 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27845 {
27846 PyThreadState* __tstate = wxPyBeginAllowThreads();
27847 delete arg1;
27848
27849 wxPyEndAllowThreads(__tstate);
27850 if (PyErr_Occurred()) SWIG_fail;
27851 }
27852 resultobj = SWIG_Py_Void();
27853 return resultobj;
27854 fail:
27855 return NULL;
27856 }
27857
27858
27859 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27860 PyObject *resultobj = 0;
27861 wxPyApp *arg1 = (wxPyApp *) 0 ;
27862 PyObject *arg2 = (PyObject *) 0 ;
27863 PyObject *arg3 = (PyObject *) 0 ;
27864 bool arg4 ;
27865 void *argp1 = 0 ;
27866 int res1 = 0 ;
27867 bool val4 ;
27868 int ecode4 = 0 ;
27869 PyObject * obj0 = 0 ;
27870 PyObject * obj1 = 0 ;
27871 PyObject * obj2 = 0 ;
27872 PyObject * obj3 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27881 }
27882 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27883 arg2 = obj1;
27884 arg3 = obj2;
27885 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27886 if (!SWIG_IsOK(ecode4)) {
27887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27888 }
27889 arg4 = static_cast< bool >(val4);
27890 {
27891 PyThreadState* __tstate = wxPyBeginAllowThreads();
27892 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 resultobj = SWIG_Py_Void();
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27904 PyObject *resultobj = 0;
27905 wxPyApp *arg1 = (wxPyApp *) 0 ;
27906 wxString result;
27907 void *argp1 = 0 ;
27908 int res1 = 0 ;
27909 PyObject *swig_obj[1] ;
27910
27911 if (!args) SWIG_fail;
27912 swig_obj[0] = args;
27913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27914 if (!SWIG_IsOK(res1)) {
27915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27916 }
27917 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27918 {
27919 PyThreadState* __tstate = wxPyBeginAllowThreads();
27920 result = ((wxPyApp const *)arg1)->GetAppName();
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 #if wxUSE_UNICODE
27926 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27927 #else
27928 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27929 #endif
27930 }
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj = 0;
27939 wxPyApp *arg1 = (wxPyApp *) 0 ;
27940 wxString *arg2 = 0 ;
27941 void *argp1 = 0 ;
27942 int res1 = 0 ;
27943 bool temp2 = false ;
27944 PyObject * obj0 = 0 ;
27945 PyObject * obj1 = 0 ;
27946 char * kwnames[] = {
27947 (char *) "self",(char *) "name", NULL
27948 };
27949
27950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27952 if (!SWIG_IsOK(res1)) {
27953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27954 }
27955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27956 {
27957 arg2 = wxString_in_helper(obj1);
27958 if (arg2 == NULL) SWIG_fail;
27959 temp2 = true;
27960 }
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 (arg1)->SetAppName((wxString const &)*arg2);
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 resultobj = SWIG_Py_Void();
27968 {
27969 if (temp2)
27970 delete arg2;
27971 }
27972 return resultobj;
27973 fail:
27974 {
27975 if (temp2)
27976 delete arg2;
27977 }
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27983 PyObject *resultobj = 0;
27984 wxPyApp *arg1 = (wxPyApp *) 0 ;
27985 wxString result;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 PyObject *swig_obj[1] ;
27989
27990 if (!args) SWIG_fail;
27991 swig_obj[0] = args;
27992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27993 if (!SWIG_IsOK(res1)) {
27994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27995 }
27996 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 result = ((wxPyApp const *)arg1)->GetClassName();
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 {
28004 #if wxUSE_UNICODE
28005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28006 #else
28007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28008 #endif
28009 }
28010 return resultobj;
28011 fail:
28012 return NULL;
28013 }
28014
28015
28016 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28017 PyObject *resultobj = 0;
28018 wxPyApp *arg1 = (wxPyApp *) 0 ;
28019 wxString *arg2 = 0 ;
28020 void *argp1 = 0 ;
28021 int res1 = 0 ;
28022 bool temp2 = false ;
28023 PyObject * obj0 = 0 ;
28024 PyObject * obj1 = 0 ;
28025 char * kwnames[] = {
28026 (char *) "self",(char *) "name", NULL
28027 };
28028
28029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28031 if (!SWIG_IsOK(res1)) {
28032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28033 }
28034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28035 {
28036 arg2 = wxString_in_helper(obj1);
28037 if (arg2 == NULL) SWIG_fail;
28038 temp2 = true;
28039 }
28040 {
28041 PyThreadState* __tstate = wxPyBeginAllowThreads();
28042 (arg1)->SetClassName((wxString const &)*arg2);
28043 wxPyEndAllowThreads(__tstate);
28044 if (PyErr_Occurred()) SWIG_fail;
28045 }
28046 resultobj = SWIG_Py_Void();
28047 {
28048 if (temp2)
28049 delete arg2;
28050 }
28051 return resultobj;
28052 fail:
28053 {
28054 if (temp2)
28055 delete arg2;
28056 }
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28062 PyObject *resultobj = 0;
28063 wxPyApp *arg1 = (wxPyApp *) 0 ;
28064 wxString *result = 0 ;
28065 void *argp1 = 0 ;
28066 int res1 = 0 ;
28067 PyObject *swig_obj[1] ;
28068
28069 if (!args) SWIG_fail;
28070 swig_obj[0] = args;
28071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28072 if (!SWIG_IsOK(res1)) {
28073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28074 }
28075 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 {
28079 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28080 result = (wxString *) &_result_ref;
28081 }
28082 wxPyEndAllowThreads(__tstate);
28083 if (PyErr_Occurred()) SWIG_fail;
28084 }
28085 {
28086 #if wxUSE_UNICODE
28087 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28088 #else
28089 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28090 #endif
28091 }
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj = 0;
28100 wxPyApp *arg1 = (wxPyApp *) 0 ;
28101 wxString *arg2 = 0 ;
28102 void *argp1 = 0 ;
28103 int res1 = 0 ;
28104 bool temp2 = false ;
28105 PyObject * obj0 = 0 ;
28106 PyObject * obj1 = 0 ;
28107 char * kwnames[] = {
28108 (char *) "self",(char *) "name", NULL
28109 };
28110
28111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28113 if (!SWIG_IsOK(res1)) {
28114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28115 }
28116 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28117 {
28118 arg2 = wxString_in_helper(obj1);
28119 if (arg2 == NULL) SWIG_fail;
28120 temp2 = true;
28121 }
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 (arg1)->SetVendorName((wxString const &)*arg2);
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_Py_Void();
28129 {
28130 if (temp2)
28131 delete arg2;
28132 }
28133 return resultobj;
28134 fail:
28135 {
28136 if (temp2)
28137 delete arg2;
28138 }
28139 return NULL;
28140 }
28141
28142
28143 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28144 PyObject *resultobj = 0;
28145 wxPyApp *arg1 = (wxPyApp *) 0 ;
28146 wxAppTraits *result = 0 ;
28147 void *argp1 = 0 ;
28148 int res1 = 0 ;
28149 PyObject *swig_obj[1] ;
28150
28151 if (!args) SWIG_fail;
28152 swig_obj[0] = args;
28153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28154 if (!SWIG_IsOK(res1)) {
28155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28156 }
28157 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (wxAppTraits *)(arg1)->GetTraits();
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28165 return resultobj;
28166 fail:
28167 return NULL;
28168 }
28169
28170
28171 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28172 PyObject *resultobj = 0;
28173 wxPyApp *arg1 = (wxPyApp *) 0 ;
28174 void *argp1 = 0 ;
28175 int res1 = 0 ;
28176 PyObject *swig_obj[1] ;
28177
28178 if (!args) SWIG_fail;
28179 swig_obj[0] = args;
28180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28181 if (!SWIG_IsOK(res1)) {
28182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28183 }
28184 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 (arg1)->ProcessPendingEvents();
28188 wxPyEndAllowThreads(__tstate);
28189 if (PyErr_Occurred()) SWIG_fail;
28190 }
28191 resultobj = SWIG_Py_Void();
28192 return resultobj;
28193 fail:
28194 return NULL;
28195 }
28196
28197
28198 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28199 PyObject *resultobj = 0;
28200 wxPyApp *arg1 = (wxPyApp *) 0 ;
28201 bool arg2 = (bool) false ;
28202 bool result;
28203 void *argp1 = 0 ;
28204 int res1 = 0 ;
28205 bool val2 ;
28206 int ecode2 = 0 ;
28207 PyObject * obj0 = 0 ;
28208 PyObject * obj1 = 0 ;
28209 char * kwnames[] = {
28210 (char *) "self",(char *) "onlyIfNeeded", NULL
28211 };
28212
28213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28215 if (!SWIG_IsOK(res1)) {
28216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28217 }
28218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28219 if (obj1) {
28220 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28221 if (!SWIG_IsOK(ecode2)) {
28222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28223 }
28224 arg2 = static_cast< bool >(val2);
28225 }
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (bool)(arg1)->Yield(arg2);
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 PyObject *resultobj = 0;
28243 wxPyApp *arg1 = (wxPyApp *) 0 ;
28244 void *argp1 = 0 ;
28245 int res1 = 0 ;
28246 PyObject *swig_obj[1] ;
28247
28248 if (!args) SWIG_fail;
28249 swig_obj[0] = args;
28250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28251 if (!SWIG_IsOK(res1)) {
28252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28253 }
28254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 (arg1)->WakeUpIdle();
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = SWIG_Py_Void();
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28269 PyObject *resultobj = 0;
28270 bool result;
28271
28272 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 result = (bool)wxPyApp::IsMainLoopRunning();
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 {
28280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28281 }
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28289 PyObject *resultobj = 0;
28290 wxPyApp *arg1 = (wxPyApp *) 0 ;
28291 int result;
28292 void *argp1 = 0 ;
28293 int res1 = 0 ;
28294 PyObject *swig_obj[1] ;
28295
28296 if (!args) SWIG_fail;
28297 swig_obj[0] = args;
28298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28301 }
28302 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28303 {
28304 PyThreadState* __tstate = wxPyBeginAllowThreads();
28305 result = (int)(arg1)->MainLoop();
28306 wxPyEndAllowThreads(__tstate);
28307 if (PyErr_Occurred()) SWIG_fail;
28308 }
28309 resultobj = SWIG_From_int(static_cast< int >(result));
28310 return resultobj;
28311 fail:
28312 return NULL;
28313 }
28314
28315
28316 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28317 PyObject *resultobj = 0;
28318 wxPyApp *arg1 = (wxPyApp *) 0 ;
28319 void *argp1 = 0 ;
28320 int res1 = 0 ;
28321 PyObject *swig_obj[1] ;
28322
28323 if (!args) SWIG_fail;
28324 swig_obj[0] = args;
28325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28326 if (!SWIG_IsOK(res1)) {
28327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28328 }
28329 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 (arg1)->Exit();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_Py_Void();
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 PyObject *resultobj = 0;
28345 wxPyApp *arg1 = (wxPyApp *) 0 ;
28346 wxLayoutDirection 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_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28356 }
28357 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 resultobj = SWIG_From_int(static_cast< int >(result));
28365 return resultobj;
28366 fail:
28367 return NULL;
28368 }
28369
28370
28371 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28372 PyObject *resultobj = 0;
28373 wxPyApp *arg1 = (wxPyApp *) 0 ;
28374 void *argp1 = 0 ;
28375 int res1 = 0 ;
28376 PyObject *swig_obj[1] ;
28377
28378 if (!args) SWIG_fail;
28379 swig_obj[0] = args;
28380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28381 if (!SWIG_IsOK(res1)) {
28382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28383 }
28384 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 (arg1)->ExitMainLoop();
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_Py_Void();
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28399 PyObject *resultobj = 0;
28400 wxPyApp *arg1 = (wxPyApp *) 0 ;
28401 bool result;
28402 void *argp1 = 0 ;
28403 int res1 = 0 ;
28404 PyObject *swig_obj[1] ;
28405
28406 if (!args) SWIG_fail;
28407 swig_obj[0] = args;
28408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28409 if (!SWIG_IsOK(res1)) {
28410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28411 }
28412 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28413 {
28414 PyThreadState* __tstate = wxPyBeginAllowThreads();
28415 result = (bool)(arg1)->Pending();
28416 wxPyEndAllowThreads(__tstate);
28417 if (PyErr_Occurred()) SWIG_fail;
28418 }
28419 {
28420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28421 }
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28429 PyObject *resultobj = 0;
28430 wxPyApp *arg1 = (wxPyApp *) 0 ;
28431 bool result;
28432 void *argp1 = 0 ;
28433 int res1 = 0 ;
28434 PyObject *swig_obj[1] ;
28435
28436 if (!args) SWIG_fail;
28437 swig_obj[0] = args;
28438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28439 if (!SWIG_IsOK(res1)) {
28440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28441 }
28442 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28443 {
28444 PyThreadState* __tstate = wxPyBeginAllowThreads();
28445 result = (bool)(arg1)->Dispatch();
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28459 PyObject *resultobj = 0;
28460 wxPyApp *arg1 = (wxPyApp *) 0 ;
28461 bool result;
28462 void *argp1 = 0 ;
28463 int res1 = 0 ;
28464 PyObject *swig_obj[1] ;
28465
28466 if (!args) SWIG_fail;
28467 swig_obj[0] = args;
28468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28469 if (!SWIG_IsOK(res1)) {
28470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28471 }
28472 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28473 {
28474 PyThreadState* __tstate = wxPyBeginAllowThreads();
28475 result = (bool)(arg1)->ProcessIdle();
28476 wxPyEndAllowThreads(__tstate);
28477 if (PyErr_Occurred()) SWIG_fail;
28478 }
28479 {
28480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28481 }
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28489 PyObject *resultobj = 0;
28490 wxPyApp *arg1 = (wxPyApp *) 0 ;
28491 wxWindow *arg2 = (wxWindow *) 0 ;
28492 wxIdleEvent *arg3 = 0 ;
28493 bool result;
28494 void *argp1 = 0 ;
28495 int res1 = 0 ;
28496 void *argp2 = 0 ;
28497 int res2 = 0 ;
28498 void *argp3 = 0 ;
28499 int res3 = 0 ;
28500 PyObject * obj0 = 0 ;
28501 PyObject * obj1 = 0 ;
28502 PyObject * obj2 = 0 ;
28503 char * kwnames[] = {
28504 (char *) "self",(char *) "win",(char *) "event", NULL
28505 };
28506
28507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28511 }
28512 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28514 if (!SWIG_IsOK(res2)) {
28515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28516 }
28517 arg2 = reinterpret_cast< wxWindow * >(argp2);
28518 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28519 if (!SWIG_IsOK(res3)) {
28520 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28521 }
28522 if (!argp3) {
28523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28524 }
28525 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28526 {
28527 PyThreadState* __tstate = wxPyBeginAllowThreads();
28528 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 {
28533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28534 }
28535 return resultobj;
28536 fail:
28537 return NULL;
28538 }
28539
28540
28541 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28542 PyObject *resultobj = 0;
28543 wxPyApp *arg1 = (wxPyApp *) 0 ;
28544 bool result;
28545 void *argp1 = 0 ;
28546 int res1 = 0 ;
28547 PyObject *swig_obj[1] ;
28548
28549 if (!args) SWIG_fail;
28550 swig_obj[0] = args;
28551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28554 }
28555 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 result = (bool)((wxPyApp const *)arg1)->IsActive();
28559 wxPyEndAllowThreads(__tstate);
28560 if (PyErr_Occurred()) SWIG_fail;
28561 }
28562 {
28563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28564 }
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28572 PyObject *resultobj = 0;
28573 wxPyApp *arg1 = (wxPyApp *) 0 ;
28574 wxWindow *arg2 = (wxWindow *) 0 ;
28575 void *argp1 = 0 ;
28576 int res1 = 0 ;
28577 void *argp2 = 0 ;
28578 int res2 = 0 ;
28579 PyObject * obj0 = 0 ;
28580 PyObject * obj1 = 0 ;
28581 char * kwnames[] = {
28582 (char *) "self",(char *) "win", NULL
28583 };
28584
28585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28587 if (!SWIG_IsOK(res1)) {
28588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28589 }
28590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28592 if (!SWIG_IsOK(res2)) {
28593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28594 }
28595 arg2 = reinterpret_cast< wxWindow * >(argp2);
28596 {
28597 PyThreadState* __tstate = wxPyBeginAllowThreads();
28598 (arg1)->SetTopWindow(arg2);
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 resultobj = SWIG_Py_Void();
28603 return resultobj;
28604 fail:
28605 return NULL;
28606 }
28607
28608
28609 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28610 PyObject *resultobj = 0;
28611 wxPyApp *arg1 = (wxPyApp *) 0 ;
28612 wxWindow *result = 0 ;
28613 void *argp1 = 0 ;
28614 int res1 = 0 ;
28615 PyObject *swig_obj[1] ;
28616
28617 if (!args) SWIG_fail;
28618 swig_obj[0] = args;
28619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28620 if (!SWIG_IsOK(res1)) {
28621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28622 }
28623 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28624 {
28625 PyThreadState* __tstate = wxPyBeginAllowThreads();
28626 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28627 wxPyEndAllowThreads(__tstate);
28628 if (PyErr_Occurred()) SWIG_fail;
28629 }
28630 {
28631 resultobj = wxPyMake_wxObject(result, (bool)0);
28632 }
28633 return resultobj;
28634 fail:
28635 return NULL;
28636 }
28637
28638
28639 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28640 PyObject *resultobj = 0;
28641 wxPyApp *arg1 = (wxPyApp *) 0 ;
28642 bool arg2 ;
28643 void *argp1 = 0 ;
28644 int res1 = 0 ;
28645 bool val2 ;
28646 int ecode2 = 0 ;
28647 PyObject * obj0 = 0 ;
28648 PyObject * obj1 = 0 ;
28649 char * kwnames[] = {
28650 (char *) "self",(char *) "flag", NULL
28651 };
28652
28653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28657 }
28658 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28659 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28660 if (!SWIG_IsOK(ecode2)) {
28661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28662 }
28663 arg2 = static_cast< bool >(val2);
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 (arg1)->SetExitOnFrameDelete(arg2);
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 resultobj = SWIG_Py_Void();
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28678 PyObject *resultobj = 0;
28679 wxPyApp *arg1 = (wxPyApp *) 0 ;
28680 bool result;
28681 void *argp1 = 0 ;
28682 int res1 = 0 ;
28683 PyObject *swig_obj[1] ;
28684
28685 if (!args) SWIG_fail;
28686 swig_obj[0] = args;
28687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28688 if (!SWIG_IsOK(res1)) {
28689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28690 }
28691 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28692 {
28693 PyThreadState* __tstate = wxPyBeginAllowThreads();
28694 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 {
28699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28700 }
28701 return resultobj;
28702 fail:
28703 return NULL;
28704 }
28705
28706
28707 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28708 PyObject *resultobj = 0;
28709 wxPyApp *arg1 = (wxPyApp *) 0 ;
28710 bool arg2 ;
28711 void *argp1 = 0 ;
28712 int res1 = 0 ;
28713 bool val2 ;
28714 int ecode2 = 0 ;
28715 PyObject * obj0 = 0 ;
28716 PyObject * obj1 = 0 ;
28717 char * kwnames[] = {
28718 (char *) "self",(char *) "flag", NULL
28719 };
28720
28721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28725 }
28726 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28728 if (!SWIG_IsOK(ecode2)) {
28729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28730 }
28731 arg2 = static_cast< bool >(val2);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 (arg1)->SetUseBestVisual(arg2);
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_Py_Void();
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28746 PyObject *resultobj = 0;
28747 wxPyApp *arg1 = (wxPyApp *) 0 ;
28748 bool result;
28749 void *argp1 = 0 ;
28750 int res1 = 0 ;
28751 PyObject *swig_obj[1] ;
28752
28753 if (!args) SWIG_fail;
28754 swig_obj[0] = args;
28755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28756 if (!SWIG_IsOK(res1)) {
28757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28758 }
28759 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28760 {
28761 PyThreadState* __tstate = wxPyBeginAllowThreads();
28762 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28763 wxPyEndAllowThreads(__tstate);
28764 if (PyErr_Occurred()) SWIG_fail;
28765 }
28766 {
28767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28768 }
28769 return resultobj;
28770 fail:
28771 return NULL;
28772 }
28773
28774
28775 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28776 PyObject *resultobj = 0;
28777 wxPyApp *arg1 = (wxPyApp *) 0 ;
28778 int arg2 ;
28779 void *argp1 = 0 ;
28780 int res1 = 0 ;
28781 int val2 ;
28782 int ecode2 = 0 ;
28783 PyObject * obj0 = 0 ;
28784 PyObject * obj1 = 0 ;
28785 char * kwnames[] = {
28786 (char *) "self",(char *) "mode", NULL
28787 };
28788
28789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28793 }
28794 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28795 ecode2 = SWIG_AsVal_int(obj1, &val2);
28796 if (!SWIG_IsOK(ecode2)) {
28797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28798 }
28799 arg2 = static_cast< int >(val2);
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 (arg1)->SetPrintMode(arg2);
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_Py_Void();
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28814 PyObject *resultobj = 0;
28815 wxPyApp *arg1 = (wxPyApp *) 0 ;
28816 int result;
28817 void *argp1 = 0 ;
28818 int res1 = 0 ;
28819 PyObject *swig_obj[1] ;
28820
28821 if (!args) SWIG_fail;
28822 swig_obj[0] = args;
28823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28824 if (!SWIG_IsOK(res1)) {
28825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28826 }
28827 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_From_int(static_cast< int >(result));
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj = 0;
28843 wxPyApp *arg1 = (wxPyApp *) 0 ;
28844 int arg2 ;
28845 void *argp1 = 0 ;
28846 int res1 = 0 ;
28847 int val2 ;
28848 int ecode2 = 0 ;
28849 PyObject * obj0 = 0 ;
28850 PyObject * obj1 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "self",(char *) "mode", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28859 }
28860 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28861 ecode2 = SWIG_AsVal_int(obj1, &val2);
28862 if (!SWIG_IsOK(ecode2)) {
28863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28864 }
28865 arg2 = static_cast< int >(val2);
28866 {
28867 PyThreadState* __tstate = wxPyBeginAllowThreads();
28868 (arg1)->SetAssertMode(arg2);
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 resultobj = SWIG_Py_Void();
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28880 PyObject *resultobj = 0;
28881 wxPyApp *arg1 = (wxPyApp *) 0 ;
28882 int result;
28883 void *argp1 = 0 ;
28884 int res1 = 0 ;
28885 PyObject *swig_obj[1] ;
28886
28887 if (!args) SWIG_fail;
28888 swig_obj[0] = args;
28889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28892 }
28893 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (int)(arg1)->GetAssertMode();
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 resultobj = SWIG_From_int(static_cast< int >(result));
28901 return resultobj;
28902 fail:
28903 return NULL;
28904 }
28905
28906
28907 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28908 PyObject *resultobj = 0;
28909 bool result;
28910
28911 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28912 {
28913 PyThreadState* __tstate = wxPyBeginAllowThreads();
28914 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 {
28919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28920 }
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 long result;
28930
28931 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28932 {
28933 PyThreadState* __tstate = wxPyBeginAllowThreads();
28934 result = (long)wxPyApp::GetMacAboutMenuItemId();
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 resultobj = SWIG_From_long(static_cast< long >(result));
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28946 PyObject *resultobj = 0;
28947 long result;
28948
28949 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28953 wxPyEndAllowThreads(__tstate);
28954 if (PyErr_Occurred()) SWIG_fail;
28955 }
28956 resultobj = SWIG_From_long(static_cast< long >(result));
28957 return resultobj;
28958 fail:
28959 return NULL;
28960 }
28961
28962
28963 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28964 PyObject *resultobj = 0;
28965 long result;
28966
28967 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28968 {
28969 PyThreadState* __tstate = wxPyBeginAllowThreads();
28970 result = (long)wxPyApp::GetMacExitMenuItemId();
28971 wxPyEndAllowThreads(__tstate);
28972 if (PyErr_Occurred()) SWIG_fail;
28973 }
28974 resultobj = SWIG_From_long(static_cast< long >(result));
28975 return resultobj;
28976 fail:
28977 return NULL;
28978 }
28979
28980
28981 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28982 PyObject *resultobj = 0;
28983 wxString result;
28984
28985 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = wxPyApp::GetMacHelpMenuTitleName();
28989 wxPyEndAllowThreads(__tstate);
28990 if (PyErr_Occurred()) SWIG_fail;
28991 }
28992 {
28993 #if wxUSE_UNICODE
28994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28995 #else
28996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28997 #endif
28998 }
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj = 0;
29007 bool arg1 ;
29008 bool val1 ;
29009 int ecode1 = 0 ;
29010 PyObject * obj0 = 0 ;
29011 char * kwnames[] = {
29012 (char *) "val", NULL
29013 };
29014
29015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29016 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29017 if (!SWIG_IsOK(ecode1)) {
29018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29019 }
29020 arg1 = static_cast< bool >(val1);
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29024 wxPyEndAllowThreads(__tstate);
29025 if (PyErr_Occurred()) SWIG_fail;
29026 }
29027 resultobj = SWIG_Py_Void();
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj = 0;
29036 long arg1 ;
29037 long val1 ;
29038 int ecode1 = 0 ;
29039 PyObject * obj0 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "val", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29045 ecode1 = SWIG_AsVal_long(obj0, &val1);
29046 if (!SWIG_IsOK(ecode1)) {
29047 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29048 }
29049 arg1 = static_cast< long >(val1);
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 wxPyApp::SetMacAboutMenuItemId(arg1);
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 resultobj = SWIG_Py_Void();
29057 return resultobj;
29058 fail:
29059 return NULL;
29060 }
29061
29062
29063 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29064 PyObject *resultobj = 0;
29065 long arg1 ;
29066 long val1 ;
29067 int ecode1 = 0 ;
29068 PyObject * obj0 = 0 ;
29069 char * kwnames[] = {
29070 (char *) "val", NULL
29071 };
29072
29073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29074 ecode1 = SWIG_AsVal_long(obj0, &val1);
29075 if (!SWIG_IsOK(ecode1)) {
29076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29077 }
29078 arg1 = static_cast< long >(val1);
29079 {
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 resultobj = SWIG_Py_Void();
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj = 0;
29094 long arg1 ;
29095 long val1 ;
29096 int ecode1 = 0 ;
29097 PyObject * obj0 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "val", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29103 ecode1 = SWIG_AsVal_long(obj0, &val1);
29104 if (!SWIG_IsOK(ecode1)) {
29105 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29106 }
29107 arg1 = static_cast< long >(val1);
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 wxPyApp::SetMacExitMenuItemId(arg1);
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 resultobj = SWIG_Py_Void();
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = 0;
29123 wxString *arg1 = 0 ;
29124 bool temp1 = false ;
29125 PyObject * obj0 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "val", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29131 {
29132 arg1 = wxString_in_helper(obj0);
29133 if (arg1 == NULL) SWIG_fail;
29134 temp1 = true;
29135 }
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 resultobj = SWIG_Py_Void();
29143 {
29144 if (temp1)
29145 delete arg1;
29146 }
29147 return resultobj;
29148 fail:
29149 {
29150 if (temp1)
29151 delete arg1;
29152 }
29153 return NULL;
29154 }
29155
29156
29157 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29158 PyObject *resultobj = 0;
29159 wxPyApp *arg1 = (wxPyApp *) 0 ;
29160 void *argp1 = 0 ;
29161 int res1 = 0 ;
29162 PyObject *swig_obj[1] ;
29163
29164 if (!args) SWIG_fail;
29165 swig_obj[0] = args;
29166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29167 if (!SWIG_IsOK(res1)) {
29168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29169 }
29170 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 (arg1)->_BootstrapApp();
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_Py_Void();
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 int result;
29187
29188 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = (int)wxPyApp::GetComCtl32Version();
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_From_int(static_cast< int >(result));
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *resultobj = 0;
29204 bool result;
29205
29206 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 result = (bool)wxPyApp_IsDisplayAvailable();
29210 wxPyEndAllowThreads(__tstate);
29211 if (PyErr_Occurred()) SWIG_fail;
29212 }
29213 {
29214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29215 }
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 PyObject *obj;
29224 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29225 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29226 return SWIG_Py_Void();
29227 }
29228
29229 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29230 return SWIG_Python_InitShadowInstance(args);
29231 }
29232
29233 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29234 PyObject *resultobj = 0;
29235
29236 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29237 {
29238 PyThreadState* __tstate = wxPyBeginAllowThreads();
29239 wxExit();
29240 wxPyEndAllowThreads(__tstate);
29241 if (PyErr_Occurred()) SWIG_fail;
29242 }
29243 resultobj = SWIG_Py_Void();
29244 return resultobj;
29245 fail:
29246 return NULL;
29247 }
29248
29249
29250 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29251 PyObject *resultobj = 0;
29252 bool result;
29253
29254 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29255 {
29256 PyThreadState* __tstate = wxPyBeginAllowThreads();
29257 result = (bool)wxYield();
29258 wxPyEndAllowThreads(__tstate);
29259 if (PyErr_Occurred()) SWIG_fail;
29260 }
29261 {
29262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29263 }
29264 return resultobj;
29265 fail:
29266 return NULL;
29267 }
29268
29269
29270 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29271 PyObject *resultobj = 0;
29272 bool result;
29273
29274 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 result = (bool)wxYieldIfNeeded();
29278 wxPyEndAllowThreads(__tstate);
29279 if (PyErr_Occurred()) SWIG_fail;
29280 }
29281 {
29282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29283 }
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj = 0;
29292 wxWindow *arg1 = (wxWindow *) NULL ;
29293 bool arg2 = (bool) false ;
29294 bool result;
29295 void *argp1 = 0 ;
29296 int res1 = 0 ;
29297 bool val2 ;
29298 int ecode2 = 0 ;
29299 PyObject * obj0 = 0 ;
29300 PyObject * obj1 = 0 ;
29301 char * kwnames[] = {
29302 (char *) "win",(char *) "onlyIfNeeded", NULL
29303 };
29304
29305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29306 if (obj0) {
29307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29308 if (!SWIG_IsOK(res1)) {
29309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29310 }
29311 arg1 = reinterpret_cast< wxWindow * >(argp1);
29312 }
29313 if (obj1) {
29314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29315 if (!SWIG_IsOK(ecode2)) {
29316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29317 }
29318 arg2 = static_cast< bool >(val2);
29319 }
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 result = (bool)wxSafeYield(arg1,arg2);
29323 wxPyEndAllowThreads(__tstate);
29324 if (PyErr_Occurred()) SWIG_fail;
29325 }
29326 {
29327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29328 }
29329 return resultobj;
29330 fail:
29331 return NULL;
29332 }
29333
29334
29335 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29336 PyObject *resultobj = 0;
29337
29338 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 wxWakeUpIdle();
29342 wxPyEndAllowThreads(__tstate);
29343 if (PyErr_Occurred()) SWIG_fail;
29344 }
29345 resultobj = SWIG_Py_Void();
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29353 PyObject *resultobj = 0;
29354 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29355 wxEvent *arg2 = 0 ;
29356 void *argp1 = 0 ;
29357 int res1 = 0 ;
29358 void *argp2 = 0 ;
29359 int res2 = 0 ;
29360 PyObject * obj0 = 0 ;
29361 PyObject * obj1 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "dest",(char *) "event", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29368 if (!SWIG_IsOK(res1)) {
29369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29370 }
29371 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29373 if (!SWIG_IsOK(res2)) {
29374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29375 }
29376 if (!argp2) {
29377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29378 }
29379 arg2 = reinterpret_cast< wxEvent * >(argp2);
29380 {
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 wxPostEvent(arg1,*arg2);
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_Py_Void();
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29394 PyObject *resultobj = 0;
29395
29396 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 wxApp_CleanUp();
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 resultobj = SWIG_Py_Void();
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29411 PyObject *resultobj = 0;
29412 wxPyApp *result = 0 ;
29413
29414 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (wxPyApp *)wxPyGetApp();
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 {
29422 resultobj = wxPyMake_wxObject(result, 0);
29423 }
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj = 0;
29432 char *arg1 = (char *) 0 ;
29433 int res1 ;
29434 char *buf1 = 0 ;
29435 int alloc1 = 0 ;
29436 PyObject * obj0 = 0 ;
29437 char * kwnames[] = {
29438 (char *) "encoding", NULL
29439 };
29440
29441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29442 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29443 if (!SWIG_IsOK(res1)) {
29444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29445 }
29446 arg1 = buf1;
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 wxSetDefaultPyEncoding((char const *)arg1);
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 resultobj = SWIG_Py_Void();
29454 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29455 return resultobj;
29456 fail:
29457 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29458 return NULL;
29459 }
29460
29461
29462 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29463 PyObject *resultobj = 0;
29464 char *result = 0 ;
29465
29466 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29467 {
29468 PyThreadState* __tstate = wxPyBeginAllowThreads();
29469 result = (char *)wxGetDefaultPyEncoding();
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 resultobj = SWIG_FromCharPtr(result);
29474 return resultobj;
29475 fail:
29476 return NULL;
29477 }
29478
29479
29480 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29481 PyObject *resultobj = 0;
29482 wxEventLoop *result = 0 ;
29483
29484 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (wxEventLoop *)new wxEventLoop();
29488 wxPyEndAllowThreads(__tstate);
29489 if (PyErr_Occurred()) SWIG_fail;
29490 }
29491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29492 return resultobj;
29493 fail:
29494 return NULL;
29495 }
29496
29497
29498 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29499 PyObject *resultobj = 0;
29500 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29501 void *argp1 = 0 ;
29502 int res1 = 0 ;
29503 PyObject *swig_obj[1] ;
29504
29505 if (!args) SWIG_fail;
29506 swig_obj[0] = args;
29507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29508 if (!SWIG_IsOK(res1)) {
29509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29510 }
29511 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29512 {
29513 PyThreadState* __tstate = wxPyBeginAllowThreads();
29514 delete arg1;
29515
29516 wxPyEndAllowThreads(__tstate);
29517 if (PyErr_Occurred()) SWIG_fail;
29518 }
29519 resultobj = SWIG_Py_Void();
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29527 PyObject *resultobj = 0;
29528 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29529 int result;
29530 void *argp1 = 0 ;
29531 int res1 = 0 ;
29532 PyObject *swig_obj[1] ;
29533
29534 if (!args) SWIG_fail;
29535 swig_obj[0] = args;
29536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29537 if (!SWIG_IsOK(res1)) {
29538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29539 }
29540 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 result = (int)(arg1)->Run();
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 resultobj = SWIG_From_int(static_cast< int >(result));
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj = 0;
29556 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29557 int arg2 = (int) 0 ;
29558 void *argp1 = 0 ;
29559 int res1 = 0 ;
29560 int val2 ;
29561 int ecode2 = 0 ;
29562 PyObject * obj0 = 0 ;
29563 PyObject * obj1 = 0 ;
29564 char * kwnames[] = {
29565 (char *) "self",(char *) "rc", NULL
29566 };
29567
29568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29570 if (!SWIG_IsOK(res1)) {
29571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29572 }
29573 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29574 if (obj1) {
29575 ecode2 = SWIG_AsVal_int(obj1, &val2);
29576 if (!SWIG_IsOK(ecode2)) {
29577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29578 }
29579 arg2 = static_cast< int >(val2);
29580 }
29581 {
29582 PyThreadState* __tstate = wxPyBeginAllowThreads();
29583 (arg1)->Exit(arg2);
29584 wxPyEndAllowThreads(__tstate);
29585 if (PyErr_Occurred()) SWIG_fail;
29586 }
29587 resultobj = SWIG_Py_Void();
29588 return resultobj;
29589 fail:
29590 return NULL;
29591 }
29592
29593
29594 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29595 PyObject *resultobj = 0;
29596 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29597 bool result;
29598 void *argp1 = 0 ;
29599 int res1 = 0 ;
29600 PyObject *swig_obj[1] ;
29601
29602 if (!args) SWIG_fail;
29603 swig_obj[0] = args;
29604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29605 if (!SWIG_IsOK(res1)) {
29606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29607 }
29608 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29609 {
29610 PyThreadState* __tstate = wxPyBeginAllowThreads();
29611 result = (bool)((wxEventLoop const *)arg1)->Pending();
29612 wxPyEndAllowThreads(__tstate);
29613 if (PyErr_Occurred()) SWIG_fail;
29614 }
29615 {
29616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29617 }
29618 return resultobj;
29619 fail:
29620 return NULL;
29621 }
29622
29623
29624 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29625 PyObject *resultobj = 0;
29626 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29627 bool result;
29628 void *argp1 = 0 ;
29629 int res1 = 0 ;
29630 PyObject *swig_obj[1] ;
29631
29632 if (!args) SWIG_fail;
29633 swig_obj[0] = args;
29634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29635 if (!SWIG_IsOK(res1)) {
29636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29637 }
29638 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29639 {
29640 PyThreadState* __tstate = wxPyBeginAllowThreads();
29641 result = (bool)(arg1)->Dispatch();
29642 wxPyEndAllowThreads(__tstate);
29643 if (PyErr_Occurred()) SWIG_fail;
29644 }
29645 {
29646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29647 }
29648 return resultobj;
29649 fail:
29650 return NULL;
29651 }
29652
29653
29654 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29655 PyObject *resultobj = 0;
29656 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29657 bool result;
29658 void *argp1 = 0 ;
29659 int res1 = 0 ;
29660 PyObject *swig_obj[1] ;
29661
29662 if (!args) SWIG_fail;
29663 swig_obj[0] = args;
29664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29665 if (!SWIG_IsOK(res1)) {
29666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29667 }
29668 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29669 {
29670 PyThreadState* __tstate = wxPyBeginAllowThreads();
29671 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29672 wxPyEndAllowThreads(__tstate);
29673 if (PyErr_Occurred()) SWIG_fail;
29674 }
29675 {
29676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29677 }
29678 return resultobj;
29679 fail:
29680 return NULL;
29681 }
29682
29683
29684 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29685 PyObject *resultobj = 0;
29686 wxEventLoop *result = 0 ;
29687
29688 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 result = (wxEventLoop *)wxEventLoop::GetActive();
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29696 return resultobj;
29697 fail:
29698 return NULL;
29699 }
29700
29701
29702 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29703 PyObject *resultobj = 0;
29704 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29705 void *argp1 = 0 ;
29706 int res1 = 0 ;
29707 PyObject * obj0 = 0 ;
29708 char * kwnames[] = {
29709 (char *) "loop", NULL
29710 };
29711
29712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29714 if (!SWIG_IsOK(res1)) {
29715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29716 }
29717 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29718 {
29719 PyThreadState* __tstate = wxPyBeginAllowThreads();
29720 wxEventLoop::SetActive(arg1);
29721 wxPyEndAllowThreads(__tstate);
29722 if (PyErr_Occurred()) SWIG_fail;
29723 }
29724 resultobj = SWIG_Py_Void();
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29732 PyObject *obj;
29733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29734 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29735 return SWIG_Py_Void();
29736 }
29737
29738 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29739 return SWIG_Python_InitShadowInstance(args);
29740 }
29741
29742 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29743 PyObject *resultobj = 0;
29744 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29745 wxEventLoopActivator *result = 0 ;
29746 void *argp1 = 0 ;
29747 int res1 = 0 ;
29748 PyObject * obj0 = 0 ;
29749 char * kwnames[] = {
29750 (char *) "evtLoop", NULL
29751 };
29752
29753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29755 if (!SWIG_IsOK(res1)) {
29756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29757 }
29758 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29759 {
29760 PyThreadState* __tstate = wxPyBeginAllowThreads();
29761 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29766 return resultobj;
29767 fail:
29768 return NULL;
29769 }
29770
29771
29772 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29773 PyObject *resultobj = 0;
29774 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29775 void *argp1 = 0 ;
29776 int res1 = 0 ;
29777 PyObject *swig_obj[1] ;
29778
29779 if (!args) SWIG_fail;
29780 swig_obj[0] = args;
29781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29782 if (!SWIG_IsOK(res1)) {
29783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29784 }
29785 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29786 {
29787 PyThreadState* __tstate = wxPyBeginAllowThreads();
29788 delete arg1;
29789
29790 wxPyEndAllowThreads(__tstate);
29791 if (PyErr_Occurred()) SWIG_fail;
29792 }
29793 resultobj = SWIG_Py_Void();
29794 return resultobj;
29795 fail:
29796 return NULL;
29797 }
29798
29799
29800 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29801 PyObject *obj;
29802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29803 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29804 return SWIG_Py_Void();
29805 }
29806
29807 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29808 return SWIG_Python_InitShadowInstance(args);
29809 }
29810
29811 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29812 PyObject *resultobj = 0;
29813 int arg1 = (int) 0 ;
29814 int arg2 = (int) 0 ;
29815 int arg3 = (int) 0 ;
29816 wxAcceleratorEntry *result = 0 ;
29817 int val1 ;
29818 int ecode1 = 0 ;
29819 int val2 ;
29820 int ecode2 = 0 ;
29821 int val3 ;
29822 int ecode3 = 0 ;
29823 PyObject * obj0 = 0 ;
29824 PyObject * obj1 = 0 ;
29825 PyObject * obj2 = 0 ;
29826 char * kwnames[] = {
29827 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29828 };
29829
29830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29831 if (obj0) {
29832 ecode1 = SWIG_AsVal_int(obj0, &val1);
29833 if (!SWIG_IsOK(ecode1)) {
29834 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29835 }
29836 arg1 = static_cast< int >(val1);
29837 }
29838 if (obj1) {
29839 ecode2 = SWIG_AsVal_int(obj1, &val2);
29840 if (!SWIG_IsOK(ecode2)) {
29841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29842 }
29843 arg2 = static_cast< int >(val2);
29844 }
29845 if (obj2) {
29846 ecode3 = SWIG_AsVal_int(obj2, &val3);
29847 if (!SWIG_IsOK(ecode3)) {
29848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29849 }
29850 arg3 = static_cast< int >(val3);
29851 }
29852 {
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29866 PyObject *resultobj = 0;
29867 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 PyObject *swig_obj[1] ;
29871
29872 if (!args) SWIG_fail;
29873 swig_obj[0] = args;
29874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29875 if (!SWIG_IsOK(res1)) {
29876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29877 }
29878 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 delete arg1;
29882
29883 wxPyEndAllowThreads(__tstate);
29884 if (PyErr_Occurred()) SWIG_fail;
29885 }
29886 resultobj = SWIG_Py_Void();
29887 return resultobj;
29888 fail:
29889 return NULL;
29890 }
29891
29892
29893 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29894 PyObject *resultobj = 0;
29895 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29896 int arg2 ;
29897 int arg3 ;
29898 int arg4 ;
29899 void *argp1 = 0 ;
29900 int res1 = 0 ;
29901 int val2 ;
29902 int ecode2 = 0 ;
29903 int val3 ;
29904 int ecode3 = 0 ;
29905 int val4 ;
29906 int ecode4 = 0 ;
29907 PyObject * obj0 = 0 ;
29908 PyObject * obj1 = 0 ;
29909 PyObject * obj2 = 0 ;
29910 PyObject * obj3 = 0 ;
29911 char * kwnames[] = {
29912 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29913 };
29914
29915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29917 if (!SWIG_IsOK(res1)) {
29918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29919 }
29920 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29921 ecode2 = SWIG_AsVal_int(obj1, &val2);
29922 if (!SWIG_IsOK(ecode2)) {
29923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29924 }
29925 arg2 = static_cast< int >(val2);
29926 ecode3 = SWIG_AsVal_int(obj2, &val3);
29927 if (!SWIG_IsOK(ecode3)) {
29928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29929 }
29930 arg3 = static_cast< int >(val3);
29931 ecode4 = SWIG_AsVal_int(obj3, &val4);
29932 if (!SWIG_IsOK(ecode4)) {
29933 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29934 }
29935 arg4 = static_cast< int >(val4);
29936 {
29937 PyThreadState* __tstate = wxPyBeginAllowThreads();
29938 (arg1)->Set(arg2,arg3,arg4);
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 resultobj = SWIG_Py_Void();
29943 return resultobj;
29944 fail:
29945 return NULL;
29946 }
29947
29948
29949 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29950 PyObject *resultobj = 0;
29951 wxString *arg1 = 0 ;
29952 wxAcceleratorEntry *result = 0 ;
29953 bool temp1 = false ;
29954 PyObject * obj0 = 0 ;
29955 char * kwnames[] = {
29956 (char *) "str", NULL
29957 };
29958
29959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29960 {
29961 arg1 = wxString_in_helper(obj0);
29962 if (arg1 == NULL) SWIG_fail;
29963 temp1 = true;
29964 }
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29972 {
29973 if (temp1)
29974 delete arg1;
29975 }
29976 return resultobj;
29977 fail:
29978 {
29979 if (temp1)
29980 delete arg1;
29981 }
29982 return NULL;
29983 }
29984
29985
29986 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29987 PyObject *resultobj = 0;
29988 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29989 int result;
29990 void *argp1 = 0 ;
29991 int res1 = 0 ;
29992 PyObject *swig_obj[1] ;
29993
29994 if (!args) SWIG_fail;
29995 swig_obj[0] = args;
29996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29997 if (!SWIG_IsOK(res1)) {
29998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29999 }
30000 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30001 {
30002 PyThreadState* __tstate = wxPyBeginAllowThreads();
30003 result = (int)(arg1)->GetFlags();
30004 wxPyEndAllowThreads(__tstate);
30005 if (PyErr_Occurred()) SWIG_fail;
30006 }
30007 resultobj = SWIG_From_int(static_cast< int >(result));
30008 return resultobj;
30009 fail:
30010 return NULL;
30011 }
30012
30013
30014 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30015 PyObject *resultobj = 0;
30016 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30017 int result;
30018 void *argp1 = 0 ;
30019 int res1 = 0 ;
30020 PyObject *swig_obj[1] ;
30021
30022 if (!args) SWIG_fail;
30023 swig_obj[0] = args;
30024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30025 if (!SWIG_IsOK(res1)) {
30026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30027 }
30028 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30029 {
30030 PyThreadState* __tstate = wxPyBeginAllowThreads();
30031 result = (int)(arg1)->GetKeyCode();
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 resultobj = SWIG_From_int(static_cast< int >(result));
30036 return resultobj;
30037 fail:
30038 return NULL;
30039 }
30040
30041
30042 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30043 PyObject *resultobj = 0;
30044 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30045 int result;
30046 void *argp1 = 0 ;
30047 int res1 = 0 ;
30048 PyObject *swig_obj[1] ;
30049
30050 if (!args) SWIG_fail;
30051 swig_obj[0] = args;
30052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30055 }
30056 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = (int)(arg1)->GetCommand();
30060 wxPyEndAllowThreads(__tstate);
30061 if (PyErr_Occurred()) SWIG_fail;
30062 }
30063 resultobj = SWIG_From_int(static_cast< int >(result));
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30073 bool result;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 PyObject *swig_obj[1] ;
30077
30078 if (!args) SWIG_fail;
30079 swig_obj[0] = args;
30080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30083 }
30084 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30093 }
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30101 PyObject *resultobj = 0;
30102 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30103 wxString result;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 PyObject *swig_obj[1] ;
30107
30108 if (!args) SWIG_fail;
30109 swig_obj[0] = args;
30110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30111 if (!SWIG_IsOK(res1)) {
30112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30113 }
30114 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 {
30122 #if wxUSE_UNICODE
30123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30124 #else
30125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30126 #endif
30127 }
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj = 0;
30136 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30137 wxString *arg2 = 0 ;
30138 bool result;
30139 void *argp1 = 0 ;
30140 int res1 = 0 ;
30141 bool temp2 = false ;
30142 PyObject * obj0 = 0 ;
30143 PyObject * obj1 = 0 ;
30144 char * kwnames[] = {
30145 (char *) "self",(char *) "str", NULL
30146 };
30147
30148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30150 if (!SWIG_IsOK(res1)) {
30151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30152 }
30153 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30154 {
30155 arg2 = wxString_in_helper(obj1);
30156 if (arg2 == NULL) SWIG_fail;
30157 temp2 = true;
30158 }
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30162 wxPyEndAllowThreads(__tstate);
30163 if (PyErr_Occurred()) SWIG_fail;
30164 }
30165 {
30166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30167 }
30168 {
30169 if (temp2)
30170 delete arg2;
30171 }
30172 return resultobj;
30173 fail:
30174 {
30175 if (temp2)
30176 delete arg2;
30177 }
30178 return NULL;
30179 }
30180
30181
30182 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30183 PyObject *obj;
30184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30185 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30186 return SWIG_Py_Void();
30187 }
30188
30189 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30190 return SWIG_Python_InitShadowInstance(args);
30191 }
30192
30193 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30194 PyObject *resultobj = 0;
30195 int arg1 ;
30196 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30197 wxAcceleratorTable *result = 0 ;
30198 PyObject * obj0 = 0 ;
30199 char * kwnames[] = {
30200 (char *) "n", NULL
30201 };
30202
30203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30204 {
30205 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30206 if (arg2) arg1 = PyList_Size(obj0);
30207 else arg1 = 0;
30208 }
30209 {
30210 PyThreadState* __tstate = wxPyBeginAllowThreads();
30211 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30212 wxPyEndAllowThreads(__tstate);
30213 if (PyErr_Occurred()) SWIG_fail;
30214 }
30215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30216 return resultobj;
30217 fail:
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 PyObject *swig_obj[1] ;
30228
30229 if (!args) SWIG_fail;
30230 swig_obj[0] = args;
30231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30232 if (!SWIG_IsOK(res1)) {
30233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30234 }
30235 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 delete arg1;
30239
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 resultobj = SWIG_Py_Void();
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30251 PyObject *resultobj = 0;
30252 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30253 bool result;
30254 void *argp1 = 0 ;
30255 int res1 = 0 ;
30256 PyObject *swig_obj[1] ;
30257
30258 if (!args) SWIG_fail;
30259 swig_obj[0] = args;
30260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30261 if (!SWIG_IsOK(res1)) {
30262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30263 }
30264 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 {
30272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30273 }
30274 return resultobj;
30275 fail:
30276 return NULL;
30277 }
30278
30279
30280 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30281 PyObject *obj;
30282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30283 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30284 return SWIG_Py_Void();
30285 }
30286
30287 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30288 return SWIG_Python_InitShadowInstance(args);
30289 }
30290
30291 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30292 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30293 return 1;
30294 }
30295
30296
30297 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30298 PyObject *pyobj = 0;
30299
30300 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30301 return pyobj;
30302 }
30303
30304
30305 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30306 PyObject *resultobj = 0;
30307 wxString *arg1 = 0 ;
30308 wxAcceleratorEntry *result = 0 ;
30309 bool temp1 = false ;
30310 PyObject * obj0 = 0 ;
30311 char * kwnames[] = {
30312 (char *) "label", NULL
30313 };
30314
30315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30316 {
30317 arg1 = wxString_in_helper(obj0);
30318 if (arg1 == NULL) SWIG_fail;
30319 temp1 = true;
30320 }
30321 {
30322 PyThreadState* __tstate = wxPyBeginAllowThreads();
30323 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30324 wxPyEndAllowThreads(__tstate);
30325 if (PyErr_Occurred()) SWIG_fail;
30326 }
30327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30328 {
30329 if (temp1)
30330 delete arg1;
30331 }
30332 return resultobj;
30333 fail:
30334 {
30335 if (temp1)
30336 delete arg1;
30337 }
30338 return NULL;
30339 }
30340
30341
30342 SWIGINTERN int PanelNameStr_set(PyObject *) {
30343 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30344 return 1;
30345 }
30346
30347
30348 SWIGINTERN PyObject *PanelNameStr_get(void) {
30349 PyObject *pyobj = 0;
30350
30351 {
30352 #if wxUSE_UNICODE
30353 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30354 #else
30355 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30356 #endif
30357 }
30358 return pyobj;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30363 PyObject *resultobj = 0;
30364 wxVisualAttributes *result = 0 ;
30365
30366 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (wxVisualAttributes *)new_wxVisualAttributes();
30370 wxPyEndAllowThreads(__tstate);
30371 if (PyErr_Occurred()) SWIG_fail;
30372 }
30373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30374 return resultobj;
30375 fail:
30376 return NULL;
30377 }
30378
30379
30380 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30381 PyObject *resultobj = 0;
30382 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30383 void *argp1 = 0 ;
30384 int res1 = 0 ;
30385 PyObject *swig_obj[1] ;
30386
30387 if (!args) SWIG_fail;
30388 swig_obj[0] = args;
30389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30390 if (!SWIG_IsOK(res1)) {
30391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30392 }
30393 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 delete_wxVisualAttributes(arg1);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 resultobj = SWIG_Py_Void();
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30409 PyObject *resultobj = 0;
30410 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30411 wxFont *arg2 = (wxFont *) 0 ;
30412 void *argp1 = 0 ;
30413 int res1 = 0 ;
30414 void *argp2 = 0 ;
30415 int res2 = 0 ;
30416 PyObject *swig_obj[2] ;
30417
30418 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30420 if (!SWIG_IsOK(res1)) {
30421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30422 }
30423 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30424 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30425 if (!SWIG_IsOK(res2)) {
30426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30427 }
30428 arg2 = reinterpret_cast< wxFont * >(argp2);
30429 if (arg1) (arg1)->font = *arg2;
30430
30431 resultobj = SWIG_Py_Void();
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30439 PyObject *resultobj = 0;
30440 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30441 wxFont *result = 0 ;
30442 void *argp1 = 0 ;
30443 int res1 = 0 ;
30444 PyObject *swig_obj[1] ;
30445
30446 if (!args) SWIG_fail;
30447 swig_obj[0] = args;
30448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30449 if (!SWIG_IsOK(res1)) {
30450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30451 }
30452 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30453 result = (wxFont *)& ((arg1)->font);
30454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30464 wxColour *arg2 = (wxColour *) 0 ;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 void *argp2 = 0 ;
30468 int res2 = 0 ;
30469 PyObject *swig_obj[2] ;
30470
30471 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30473 if (!SWIG_IsOK(res1)) {
30474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30475 }
30476 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30477 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30478 if (!SWIG_IsOK(res2)) {
30479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30480 }
30481 arg2 = reinterpret_cast< wxColour * >(argp2);
30482 if (arg1) (arg1)->colFg = *arg2;
30483
30484 resultobj = SWIG_Py_Void();
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30492 PyObject *resultobj = 0;
30493 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30494 wxColour *result = 0 ;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 PyObject *swig_obj[1] ;
30498
30499 if (!args) SWIG_fail;
30500 swig_obj[0] = args;
30501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30502 if (!SWIG_IsOK(res1)) {
30503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30504 }
30505 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30506 result = (wxColour *)& ((arg1)->colFg);
30507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30515 PyObject *resultobj = 0;
30516 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30517 wxColour *arg2 = (wxColour *) 0 ;
30518 void *argp1 = 0 ;
30519 int res1 = 0 ;
30520 void *argp2 = 0 ;
30521 int res2 = 0 ;
30522 PyObject *swig_obj[2] ;
30523
30524 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30526 if (!SWIG_IsOK(res1)) {
30527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30528 }
30529 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30530 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30531 if (!SWIG_IsOK(res2)) {
30532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30533 }
30534 arg2 = reinterpret_cast< wxColour * >(argp2);
30535 if (arg1) (arg1)->colBg = *arg2;
30536
30537 resultobj = SWIG_Py_Void();
30538 return resultobj;
30539 fail:
30540 return NULL;
30541 }
30542
30543
30544 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30545 PyObject *resultobj = 0;
30546 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30547 wxColour *result = 0 ;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 PyObject *swig_obj[1] ;
30551
30552 if (!args) SWIG_fail;
30553 swig_obj[0] = args;
30554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30555 if (!SWIG_IsOK(res1)) {
30556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30557 }
30558 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30559 result = (wxColour *)& ((arg1)->colBg);
30560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30568 PyObject *obj;
30569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30570 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30571 return SWIG_Py_Void();
30572 }
30573
30574 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30575 return SWIG_Python_InitShadowInstance(args);
30576 }
30577
30578 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj = 0;
30580 wxWindow *arg1 = (wxWindow *) 0 ;
30581 int arg2 = (int) (int)-1 ;
30582 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30583 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30584 wxSize const &arg4_defvalue = wxDefaultSize ;
30585 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30586 long arg5 = (long) 0 ;
30587 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30588 wxString *arg6 = (wxString *) &arg6_defvalue ;
30589 wxWindow *result = 0 ;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 int val2 ;
30593 int ecode2 = 0 ;
30594 wxPoint temp3 ;
30595 wxSize temp4 ;
30596 long val5 ;
30597 int ecode5 = 0 ;
30598 bool temp6 = false ;
30599 PyObject * obj0 = 0 ;
30600 PyObject * obj1 = 0 ;
30601 PyObject * obj2 = 0 ;
30602 PyObject * obj3 = 0 ;
30603 PyObject * obj4 = 0 ;
30604 PyObject * obj5 = 0 ;
30605 char * kwnames[] = {
30606 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30607 };
30608
30609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 if (obj1) {
30616 ecode2 = SWIG_AsVal_int(obj1, &val2);
30617 if (!SWIG_IsOK(ecode2)) {
30618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30619 }
30620 arg2 = static_cast< int >(val2);
30621 }
30622 if (obj2) {
30623 {
30624 arg3 = &temp3;
30625 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30626 }
30627 }
30628 if (obj3) {
30629 {
30630 arg4 = &temp4;
30631 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30632 }
30633 }
30634 if (obj4) {
30635 ecode5 = SWIG_AsVal_long(obj4, &val5);
30636 if (!SWIG_IsOK(ecode5)) {
30637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30638 }
30639 arg5 = static_cast< long >(val5);
30640 }
30641 if (obj5) {
30642 {
30643 arg6 = wxString_in_helper(obj5);
30644 if (arg6 == NULL) SWIG_fail;
30645 temp6 = true;
30646 }
30647 }
30648 {
30649 if (!wxPyCheckForApp()) SWIG_fail;
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30656 {
30657 if (temp6)
30658 delete arg6;
30659 }
30660 return resultobj;
30661 fail:
30662 {
30663 if (temp6)
30664 delete arg6;
30665 }
30666 return NULL;
30667 }
30668
30669
30670 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30671 PyObject *resultobj = 0;
30672 wxWindow *result = 0 ;
30673
30674 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30675 {
30676 if (!wxPyCheckForApp()) SWIG_fail;
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (wxWindow *)new wxWindow();
30679 wxPyEndAllowThreads(__tstate);
30680 if (PyErr_Occurred()) SWIG_fail;
30681 }
30682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30683 return resultobj;
30684 fail:
30685 return NULL;
30686 }
30687
30688
30689 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30690 PyObject *resultobj = 0;
30691 wxWindow *arg1 = (wxWindow *) 0 ;
30692 wxWindow *arg2 = (wxWindow *) 0 ;
30693 int arg3 = (int) (int)-1 ;
30694 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30695 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30696 wxSize const &arg5_defvalue = wxDefaultSize ;
30697 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30698 long arg6 = (long) 0 ;
30699 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30700 wxString *arg7 = (wxString *) &arg7_defvalue ;
30701 bool result;
30702 void *argp1 = 0 ;
30703 int res1 = 0 ;
30704 void *argp2 = 0 ;
30705 int res2 = 0 ;
30706 int val3 ;
30707 int ecode3 = 0 ;
30708 wxPoint temp4 ;
30709 wxSize temp5 ;
30710 long val6 ;
30711 int ecode6 = 0 ;
30712 bool temp7 = false ;
30713 PyObject * obj0 = 0 ;
30714 PyObject * obj1 = 0 ;
30715 PyObject * obj2 = 0 ;
30716 PyObject * obj3 = 0 ;
30717 PyObject * obj4 = 0 ;
30718 PyObject * obj5 = 0 ;
30719 PyObject * obj6 = 0 ;
30720 char * kwnames[] = {
30721 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30722 };
30723
30724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30726 if (!SWIG_IsOK(res1)) {
30727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30728 }
30729 arg1 = reinterpret_cast< wxWindow * >(argp1);
30730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30731 if (!SWIG_IsOK(res2)) {
30732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30733 }
30734 arg2 = reinterpret_cast< wxWindow * >(argp2);
30735 if (obj2) {
30736 ecode3 = SWIG_AsVal_int(obj2, &val3);
30737 if (!SWIG_IsOK(ecode3)) {
30738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30739 }
30740 arg3 = static_cast< int >(val3);
30741 }
30742 if (obj3) {
30743 {
30744 arg4 = &temp4;
30745 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30746 }
30747 }
30748 if (obj4) {
30749 {
30750 arg5 = &temp5;
30751 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30752 }
30753 }
30754 if (obj5) {
30755 ecode6 = SWIG_AsVal_long(obj5, &val6);
30756 if (!SWIG_IsOK(ecode6)) {
30757 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30758 }
30759 arg6 = static_cast< long >(val6);
30760 }
30761 if (obj6) {
30762 {
30763 arg7 = wxString_in_helper(obj6);
30764 if (arg7 == NULL) SWIG_fail;
30765 temp7 = true;
30766 }
30767 }
30768 {
30769 PyThreadState* __tstate = wxPyBeginAllowThreads();
30770 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 {
30775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30776 }
30777 {
30778 if (temp7)
30779 delete arg7;
30780 }
30781 return resultobj;
30782 fail:
30783 {
30784 if (temp7)
30785 delete arg7;
30786 }
30787 return NULL;
30788 }
30789
30790
30791 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30792 PyObject *resultobj = 0;
30793 wxWindow *arg1 = (wxWindow *) 0 ;
30794 bool arg2 = (bool) false ;
30795 bool result;
30796 void *argp1 = 0 ;
30797 int res1 = 0 ;
30798 bool val2 ;
30799 int ecode2 = 0 ;
30800 PyObject * obj0 = 0 ;
30801 PyObject * obj1 = 0 ;
30802 char * kwnames[] = {
30803 (char *) "self",(char *) "force", NULL
30804 };
30805
30806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30808 if (!SWIG_IsOK(res1)) {
30809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30810 }
30811 arg1 = reinterpret_cast< wxWindow * >(argp1);
30812 if (obj1) {
30813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30814 if (!SWIG_IsOK(ecode2)) {
30815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30816 }
30817 arg2 = static_cast< bool >(val2);
30818 }
30819 {
30820 PyThreadState* __tstate = wxPyBeginAllowThreads();
30821 result = (bool)(arg1)->Close(arg2);
30822 wxPyEndAllowThreads(__tstate);
30823 if (PyErr_Occurred()) SWIG_fail;
30824 }
30825 {
30826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 bool result;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 PyObject *swig_obj[1] ;
30841
30842 if (!args) SWIG_fail;
30843 swig_obj[0] = args;
30844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30847 }
30848 arg1 = reinterpret_cast< wxWindow * >(argp1);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (bool)(arg1)->Destroy();
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 {
30856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30857 }
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 bool result;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 PyObject *swig_obj[1] ;
30871
30872 if (!args) SWIG_fail;
30873 swig_obj[0] = args;
30874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30875 if (!SWIG_IsOK(res1)) {
30876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30877 }
30878 arg1 = reinterpret_cast< wxWindow * >(argp1);
30879 {
30880 PyThreadState* __tstate = wxPyBeginAllowThreads();
30881 result = (bool)(arg1)->DestroyChildren();
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 {
30886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30887 }
30888 return resultobj;
30889 fail:
30890 return NULL;
30891 }
30892
30893
30894 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30895 PyObject *resultobj = 0;
30896 wxWindow *arg1 = (wxWindow *) 0 ;
30897 bool result;
30898 void *argp1 = 0 ;
30899 int res1 = 0 ;
30900 PyObject *swig_obj[1] ;
30901
30902 if (!args) SWIG_fail;
30903 swig_obj[0] = args;
30904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res1)) {
30906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30907 }
30908 arg1 = reinterpret_cast< wxWindow * >(argp1);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 {
30916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30917 }
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30925 PyObject *resultobj = 0;
30926 wxWindow *arg1 = (wxWindow *) 0 ;
30927 wxString *arg2 = 0 ;
30928 void *argp1 = 0 ;
30929 int res1 = 0 ;
30930 bool temp2 = false ;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 char * kwnames[] = {
30934 (char *) "self",(char *) "label", NULL
30935 };
30936
30937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30939 if (!SWIG_IsOK(res1)) {
30940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30941 }
30942 arg1 = reinterpret_cast< wxWindow * >(argp1);
30943 {
30944 arg2 = wxString_in_helper(obj1);
30945 if (arg2 == NULL) SWIG_fail;
30946 temp2 = true;
30947 }
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 (arg1)->SetLabel((wxString const &)*arg2);
30951 wxPyEndAllowThreads(__tstate);
30952 if (PyErr_Occurred()) SWIG_fail;
30953 }
30954 resultobj = SWIG_Py_Void();
30955 {
30956 if (temp2)
30957 delete arg2;
30958 }
30959 return resultobj;
30960 fail:
30961 {
30962 if (temp2)
30963 delete arg2;
30964 }
30965 return NULL;
30966 }
30967
30968
30969 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30970 PyObject *resultobj = 0;
30971 wxWindow *arg1 = (wxWindow *) 0 ;
30972 wxString result;
30973 void *argp1 = 0 ;
30974 int res1 = 0 ;
30975 PyObject *swig_obj[1] ;
30976
30977 if (!args) SWIG_fail;
30978 swig_obj[0] = args;
30979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30980 if (!SWIG_IsOK(res1)) {
30981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30982 }
30983 arg1 = reinterpret_cast< wxWindow * >(argp1);
30984 {
30985 PyThreadState* __tstate = wxPyBeginAllowThreads();
30986 result = ((wxWindow const *)arg1)->GetLabel();
30987 wxPyEndAllowThreads(__tstate);
30988 if (PyErr_Occurred()) SWIG_fail;
30989 }
30990 {
30991 #if wxUSE_UNICODE
30992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30993 #else
30994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30995 #endif
30996 }
30997 return resultobj;
30998 fail:
30999 return NULL;
31000 }
31001
31002
31003 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31004 PyObject *resultobj = 0;
31005 wxWindow *arg1 = (wxWindow *) 0 ;
31006 wxString *arg2 = 0 ;
31007 void *argp1 = 0 ;
31008 int res1 = 0 ;
31009 bool temp2 = false ;
31010 PyObject * obj0 = 0 ;
31011 PyObject * obj1 = 0 ;
31012 char * kwnames[] = {
31013 (char *) "self",(char *) "name", NULL
31014 };
31015
31016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31018 if (!SWIG_IsOK(res1)) {
31019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31020 }
31021 arg1 = reinterpret_cast< wxWindow * >(argp1);
31022 {
31023 arg2 = wxString_in_helper(obj1);
31024 if (arg2 == NULL) SWIG_fail;
31025 temp2 = true;
31026 }
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 (arg1)->SetName((wxString const &)*arg2);
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_Py_Void();
31034 {
31035 if (temp2)
31036 delete arg2;
31037 }
31038 return resultobj;
31039 fail:
31040 {
31041 if (temp2)
31042 delete arg2;
31043 }
31044 return NULL;
31045 }
31046
31047
31048 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31049 PyObject *resultobj = 0;
31050 wxWindow *arg1 = (wxWindow *) 0 ;
31051 wxString result;
31052 void *argp1 = 0 ;
31053 int res1 = 0 ;
31054 PyObject *swig_obj[1] ;
31055
31056 if (!args) SWIG_fail;
31057 swig_obj[0] = args;
31058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31059 if (!SWIG_IsOK(res1)) {
31060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31061 }
31062 arg1 = reinterpret_cast< wxWindow * >(argp1);
31063 {
31064 PyThreadState* __tstate = wxPyBeginAllowThreads();
31065 result = ((wxWindow const *)arg1)->GetName();
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 {
31070 #if wxUSE_UNICODE
31071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31072 #else
31073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31074 #endif
31075 }
31076 return resultobj;
31077 fail:
31078 return NULL;
31079 }
31080
31081
31082 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31083 PyObject *resultobj = 0;
31084 wxWindow *arg1 = (wxWindow *) 0 ;
31085 wxWindowVariant arg2 ;
31086 void *argp1 = 0 ;
31087 int res1 = 0 ;
31088 int val2 ;
31089 int ecode2 = 0 ;
31090 PyObject * obj0 = 0 ;
31091 PyObject * obj1 = 0 ;
31092 char * kwnames[] = {
31093 (char *) "self",(char *) "variant", NULL
31094 };
31095
31096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31098 if (!SWIG_IsOK(res1)) {
31099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31100 }
31101 arg1 = reinterpret_cast< wxWindow * >(argp1);
31102 ecode2 = SWIG_AsVal_int(obj1, &val2);
31103 if (!SWIG_IsOK(ecode2)) {
31104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31105 }
31106 arg2 = static_cast< wxWindowVariant >(val2);
31107 {
31108 PyThreadState* __tstate = wxPyBeginAllowThreads();
31109 (arg1)->SetWindowVariant(arg2);
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 resultobj = SWIG_Py_Void();
31114 return resultobj;
31115 fail:
31116 return NULL;
31117 }
31118
31119
31120 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31121 PyObject *resultobj = 0;
31122 wxWindow *arg1 = (wxWindow *) 0 ;
31123 wxWindowVariant result;
31124 void *argp1 = 0 ;
31125 int res1 = 0 ;
31126 PyObject *swig_obj[1] ;
31127
31128 if (!args) SWIG_fail;
31129 swig_obj[0] = args;
31130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31131 if (!SWIG_IsOK(res1)) {
31132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31133 }
31134 arg1 = reinterpret_cast< wxWindow * >(argp1);
31135 {
31136 PyThreadState* __tstate = wxPyBeginAllowThreads();
31137 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 resultobj = SWIG_From_int(static_cast< int >(result));
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj = 0;
31150 wxWindow *arg1 = (wxWindow *) 0 ;
31151 int arg2 ;
31152 void *argp1 = 0 ;
31153 int res1 = 0 ;
31154 int val2 ;
31155 int ecode2 = 0 ;
31156 PyObject * obj0 = 0 ;
31157 PyObject * obj1 = 0 ;
31158 char * kwnames[] = {
31159 (char *) "self",(char *) "winid", NULL
31160 };
31161
31162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31164 if (!SWIG_IsOK(res1)) {
31165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31166 }
31167 arg1 = reinterpret_cast< wxWindow * >(argp1);
31168 ecode2 = SWIG_AsVal_int(obj1, &val2);
31169 if (!SWIG_IsOK(ecode2)) {
31170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31171 }
31172 arg2 = static_cast< int >(val2);
31173 {
31174 PyThreadState* __tstate = wxPyBeginAllowThreads();
31175 (arg1)->SetId(arg2);
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 resultobj = SWIG_Py_Void();
31180 return resultobj;
31181 fail:
31182 return NULL;
31183 }
31184
31185
31186 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31187 PyObject *resultobj = 0;
31188 wxWindow *arg1 = (wxWindow *) 0 ;
31189 int result;
31190 void *argp1 = 0 ;
31191 int res1 = 0 ;
31192 PyObject *swig_obj[1] ;
31193
31194 if (!args) SWIG_fail;
31195 swig_obj[0] = args;
31196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31197 if (!SWIG_IsOK(res1)) {
31198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31199 }
31200 arg1 = reinterpret_cast< wxWindow * >(argp1);
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = (int)((wxWindow const *)arg1)->GetId();
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 resultobj = SWIG_From_int(static_cast< int >(result));
31208 return resultobj;
31209 fail:
31210 return NULL;
31211 }
31212
31213
31214 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31215 PyObject *resultobj = 0;
31216 int result;
31217
31218 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (int)wxWindow::NewControlId();
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_From_int(static_cast< int >(result));
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj = 0;
31234 int arg1 ;
31235 int result;
31236 int val1 ;
31237 int ecode1 = 0 ;
31238 PyObject * obj0 = 0 ;
31239 char * kwnames[] = {
31240 (char *) "winid", NULL
31241 };
31242
31243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31244 ecode1 = SWIG_AsVal_int(obj0, &val1);
31245 if (!SWIG_IsOK(ecode1)) {
31246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31247 }
31248 arg1 = static_cast< int >(val1);
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = (int)wxWindow::NextControlId(arg1);
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 resultobj = SWIG_From_int(static_cast< int >(result));
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31263 PyObject *resultobj = 0;
31264 int arg1 ;
31265 int result;
31266 int val1 ;
31267 int ecode1 = 0 ;
31268 PyObject * obj0 = 0 ;
31269 char * kwnames[] = {
31270 (char *) "winid", NULL
31271 };
31272
31273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31274 ecode1 = SWIG_AsVal_int(obj0, &val1);
31275 if (!SWIG_IsOK(ecode1)) {
31276 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31277 }
31278 arg1 = static_cast< int >(val1);
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 result = (int)wxWindow::PrevControlId(arg1);
31282 wxPyEndAllowThreads(__tstate);
31283 if (PyErr_Occurred()) SWIG_fail;
31284 }
31285 resultobj = SWIG_From_int(static_cast< int >(result));
31286 return resultobj;
31287 fail:
31288 return NULL;
31289 }
31290
31291
31292 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31293 PyObject *resultobj = 0;
31294 wxWindow *arg1 = (wxWindow *) 0 ;
31295 wxLayoutDirection result;
31296 void *argp1 = 0 ;
31297 int res1 = 0 ;
31298 PyObject *swig_obj[1] ;
31299
31300 if (!args) SWIG_fail;
31301 swig_obj[0] = args;
31302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31303 if (!SWIG_IsOK(res1)) {
31304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31305 }
31306 arg1 = reinterpret_cast< wxWindow * >(argp1);
31307 {
31308 PyThreadState* __tstate = wxPyBeginAllowThreads();
31309 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31310 wxPyEndAllowThreads(__tstate);
31311 if (PyErr_Occurred()) SWIG_fail;
31312 }
31313 resultobj = SWIG_From_int(static_cast< int >(result));
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31321 PyObject *resultobj = 0;
31322 wxWindow *arg1 = (wxWindow *) 0 ;
31323 wxLayoutDirection arg2 ;
31324 void *argp1 = 0 ;
31325 int res1 = 0 ;
31326 int val2 ;
31327 int ecode2 = 0 ;
31328 PyObject * obj0 = 0 ;
31329 PyObject * obj1 = 0 ;
31330 char * kwnames[] = {
31331 (char *) "self",(char *) "dir", NULL
31332 };
31333
31334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31336 if (!SWIG_IsOK(res1)) {
31337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31338 }
31339 arg1 = reinterpret_cast< wxWindow * >(argp1);
31340 ecode2 = SWIG_AsVal_int(obj1, &val2);
31341 if (!SWIG_IsOK(ecode2)) {
31342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31343 }
31344 arg2 = static_cast< wxLayoutDirection >(val2);
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 (arg1)->SetLayoutDirection(arg2);
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj = 0;
31360 wxWindow *arg1 = (wxWindow *) 0 ;
31361 int arg2 ;
31362 int arg3 ;
31363 int arg4 ;
31364 int result;
31365 void *argp1 = 0 ;
31366 int res1 = 0 ;
31367 int val2 ;
31368 int ecode2 = 0 ;
31369 int val3 ;
31370 int ecode3 = 0 ;
31371 int val4 ;
31372 int ecode4 = 0 ;
31373 PyObject * obj0 = 0 ;
31374 PyObject * obj1 = 0 ;
31375 PyObject * obj2 = 0 ;
31376 PyObject * obj3 = 0 ;
31377 char * kwnames[] = {
31378 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31379 };
31380
31381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31383 if (!SWIG_IsOK(res1)) {
31384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31385 }
31386 arg1 = reinterpret_cast< wxWindow * >(argp1);
31387 ecode2 = SWIG_AsVal_int(obj1, &val2);
31388 if (!SWIG_IsOK(ecode2)) {
31389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31390 }
31391 arg2 = static_cast< int >(val2);
31392 ecode3 = SWIG_AsVal_int(obj2, &val3);
31393 if (!SWIG_IsOK(ecode3)) {
31394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31395 }
31396 arg3 = static_cast< int >(val3);
31397 ecode4 = SWIG_AsVal_int(obj3, &val4);
31398 if (!SWIG_IsOK(ecode4)) {
31399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31400 }
31401 arg4 = static_cast< int >(val4);
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31405 wxPyEndAllowThreads(__tstate);
31406 if (PyErr_Occurred()) SWIG_fail;
31407 }
31408 resultobj = SWIG_From_int(static_cast< int >(result));
31409 return resultobj;
31410 fail:
31411 return NULL;
31412 }
31413
31414
31415 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31416 PyObject *resultobj = 0;
31417 wxWindow *arg1 = (wxWindow *) 0 ;
31418 wxSize *arg2 = 0 ;
31419 void *argp1 = 0 ;
31420 int res1 = 0 ;
31421 wxSize temp2 ;
31422 PyObject * obj0 = 0 ;
31423 PyObject * obj1 = 0 ;
31424 char * kwnames[] = {
31425 (char *) "self",(char *) "size", NULL
31426 };
31427
31428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31430 if (!SWIG_IsOK(res1)) {
31431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31432 }
31433 arg1 = reinterpret_cast< wxWindow * >(argp1);
31434 {
31435 arg2 = &temp2;
31436 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31437 }
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 (arg1)->SetSize((wxSize const &)*arg2);
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 resultobj = SWIG_Py_Void();
31445 return resultobj;
31446 fail:
31447 return NULL;
31448 }
31449
31450
31451 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31452 PyObject *resultobj = 0;
31453 wxWindow *arg1 = (wxWindow *) 0 ;
31454 int arg2 ;
31455 int arg3 ;
31456 int arg4 ;
31457 int arg5 ;
31458 int arg6 = (int) wxSIZE_AUTO ;
31459 void *argp1 = 0 ;
31460 int res1 = 0 ;
31461 int val2 ;
31462 int ecode2 = 0 ;
31463 int val3 ;
31464 int ecode3 = 0 ;
31465 int val4 ;
31466 int ecode4 = 0 ;
31467 int val5 ;
31468 int ecode5 = 0 ;
31469 int val6 ;
31470 int ecode6 = 0 ;
31471 PyObject * obj0 = 0 ;
31472 PyObject * obj1 = 0 ;
31473 PyObject * obj2 = 0 ;
31474 PyObject * obj3 = 0 ;
31475 PyObject * obj4 = 0 ;
31476 PyObject * obj5 = 0 ;
31477 char * kwnames[] = {
31478 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31479 };
31480
31481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31483 if (!SWIG_IsOK(res1)) {
31484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31485 }
31486 arg1 = reinterpret_cast< wxWindow * >(argp1);
31487 ecode2 = SWIG_AsVal_int(obj1, &val2);
31488 if (!SWIG_IsOK(ecode2)) {
31489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31490 }
31491 arg2 = static_cast< int >(val2);
31492 ecode3 = SWIG_AsVal_int(obj2, &val3);
31493 if (!SWIG_IsOK(ecode3)) {
31494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31495 }
31496 arg3 = static_cast< int >(val3);
31497 ecode4 = SWIG_AsVal_int(obj3, &val4);
31498 if (!SWIG_IsOK(ecode4)) {
31499 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31500 }
31501 arg4 = static_cast< int >(val4);
31502 ecode5 = SWIG_AsVal_int(obj4, &val5);
31503 if (!SWIG_IsOK(ecode5)) {
31504 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31505 }
31506 arg5 = static_cast< int >(val5);
31507 if (obj5) {
31508 ecode6 = SWIG_AsVal_int(obj5, &val6);
31509 if (!SWIG_IsOK(ecode6)) {
31510 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31511 }
31512 arg6 = static_cast< int >(val6);
31513 }
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31517 wxPyEndAllowThreads(__tstate);
31518 if (PyErr_Occurred()) SWIG_fail;
31519 }
31520 resultobj = SWIG_Py_Void();
31521 return resultobj;
31522 fail:
31523 return NULL;
31524 }
31525
31526
31527 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31528 PyObject *resultobj = 0;
31529 wxWindow *arg1 = (wxWindow *) 0 ;
31530 wxRect *arg2 = 0 ;
31531 int arg3 = (int) wxSIZE_AUTO ;
31532 void *argp1 = 0 ;
31533 int res1 = 0 ;
31534 wxRect temp2 ;
31535 int val3 ;
31536 int ecode3 = 0 ;
31537 PyObject * obj0 = 0 ;
31538 PyObject * obj1 = 0 ;
31539 PyObject * obj2 = 0 ;
31540 char * kwnames[] = {
31541 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31542 };
31543
31544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31546 if (!SWIG_IsOK(res1)) {
31547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31548 }
31549 arg1 = reinterpret_cast< wxWindow * >(argp1);
31550 {
31551 arg2 = &temp2;
31552 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31553 }
31554 if (obj2) {
31555 ecode3 = SWIG_AsVal_int(obj2, &val3);
31556 if (!SWIG_IsOK(ecode3)) {
31557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31558 }
31559 arg3 = static_cast< int >(val3);
31560 }
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_Py_Void();
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj = 0;
31576 wxWindow *arg1 = (wxWindow *) 0 ;
31577 int arg2 ;
31578 int arg3 ;
31579 void *argp1 = 0 ;
31580 int res1 = 0 ;
31581 int val2 ;
31582 int ecode2 = 0 ;
31583 int val3 ;
31584 int ecode3 = 0 ;
31585 PyObject * obj0 = 0 ;
31586 PyObject * obj1 = 0 ;
31587 PyObject * obj2 = 0 ;
31588 char * kwnames[] = {
31589 (char *) "self",(char *) "width",(char *) "height", NULL
31590 };
31591
31592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31594 if (!SWIG_IsOK(res1)) {
31595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31596 }
31597 arg1 = reinterpret_cast< wxWindow * >(argp1);
31598 ecode2 = SWIG_AsVal_int(obj1, &val2);
31599 if (!SWIG_IsOK(ecode2)) {
31600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31601 }
31602 arg2 = static_cast< int >(val2);
31603 ecode3 = SWIG_AsVal_int(obj2, &val3);
31604 if (!SWIG_IsOK(ecode3)) {
31605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31606 }
31607 arg3 = static_cast< int >(val3);
31608 {
31609 PyThreadState* __tstate = wxPyBeginAllowThreads();
31610 (arg1)->SetSize(arg2,arg3);
31611 wxPyEndAllowThreads(__tstate);
31612 if (PyErr_Occurred()) SWIG_fail;
31613 }
31614 resultobj = SWIG_Py_Void();
31615 return resultobj;
31616 fail:
31617 return NULL;
31618 }
31619
31620
31621 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31622 PyObject *resultobj = 0;
31623 wxWindow *arg1 = (wxWindow *) 0 ;
31624 wxPoint *arg2 = 0 ;
31625 int arg3 = (int) wxSIZE_USE_EXISTING ;
31626 void *argp1 = 0 ;
31627 int res1 = 0 ;
31628 wxPoint temp2 ;
31629 int val3 ;
31630 int ecode3 = 0 ;
31631 PyObject * obj0 = 0 ;
31632 PyObject * obj1 = 0 ;
31633 PyObject * obj2 = 0 ;
31634 char * kwnames[] = {
31635 (char *) "self",(char *) "pt",(char *) "flags", NULL
31636 };
31637
31638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31640 if (!SWIG_IsOK(res1)) {
31641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31642 }
31643 arg1 = reinterpret_cast< wxWindow * >(argp1);
31644 {
31645 arg2 = &temp2;
31646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31647 }
31648 if (obj2) {
31649 ecode3 = SWIG_AsVal_int(obj2, &val3);
31650 if (!SWIG_IsOK(ecode3)) {
31651 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31652 }
31653 arg3 = static_cast< int >(val3);
31654 }
31655 {
31656 PyThreadState* __tstate = wxPyBeginAllowThreads();
31657 (arg1)->Move((wxPoint const &)*arg2,arg3);
31658 wxPyEndAllowThreads(__tstate);
31659 if (PyErr_Occurred()) SWIG_fail;
31660 }
31661 resultobj = SWIG_Py_Void();
31662 return resultobj;
31663 fail:
31664 return NULL;
31665 }
31666
31667
31668 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31669 PyObject *resultobj = 0;
31670 wxWindow *arg1 = (wxWindow *) 0 ;
31671 int arg2 ;
31672 int arg3 ;
31673 int arg4 = (int) wxSIZE_USE_EXISTING ;
31674 void *argp1 = 0 ;
31675 int res1 = 0 ;
31676 int val2 ;
31677 int ecode2 = 0 ;
31678 int val3 ;
31679 int ecode3 = 0 ;
31680 int val4 ;
31681 int ecode4 = 0 ;
31682 PyObject * obj0 = 0 ;
31683 PyObject * obj1 = 0 ;
31684 PyObject * obj2 = 0 ;
31685 PyObject * obj3 = 0 ;
31686 char * kwnames[] = {
31687 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31688 };
31689
31690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31692 if (!SWIG_IsOK(res1)) {
31693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31694 }
31695 arg1 = reinterpret_cast< wxWindow * >(argp1);
31696 ecode2 = SWIG_AsVal_int(obj1, &val2);
31697 if (!SWIG_IsOK(ecode2)) {
31698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31699 }
31700 arg2 = static_cast< int >(val2);
31701 ecode3 = SWIG_AsVal_int(obj2, &val3);
31702 if (!SWIG_IsOK(ecode3)) {
31703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31704 }
31705 arg3 = static_cast< int >(val3);
31706 if (obj3) {
31707 ecode4 = SWIG_AsVal_int(obj3, &val4);
31708 if (!SWIG_IsOK(ecode4)) {
31709 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31710 }
31711 arg4 = static_cast< int >(val4);
31712 }
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 (arg1)->Move(arg2,arg3,arg4);
31716 wxPyEndAllowThreads(__tstate);
31717 if (PyErr_Occurred()) SWIG_fail;
31718 }
31719 resultobj = SWIG_Py_Void();
31720 return resultobj;
31721 fail:
31722 return NULL;
31723 }
31724
31725
31726 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31727 PyObject *resultobj = 0;
31728 wxWindow *arg1 = (wxWindow *) 0 ;
31729 wxSize const &arg2_defvalue = wxDefaultSize ;
31730 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31731 void *argp1 = 0 ;
31732 int res1 = 0 ;
31733 wxSize temp2 ;
31734 PyObject * obj0 = 0 ;
31735 PyObject * obj1 = 0 ;
31736 char * kwnames[] = {
31737 (char *) "self",(char *) "size", NULL
31738 };
31739
31740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31742 if (!SWIG_IsOK(res1)) {
31743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31744 }
31745 arg1 = reinterpret_cast< wxWindow * >(argp1);
31746 if (obj1) {
31747 {
31748 arg2 = &temp2;
31749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31750 }
31751 }
31752 {
31753 PyThreadState* __tstate = wxPyBeginAllowThreads();
31754 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31755 wxPyEndAllowThreads(__tstate);
31756 if (PyErr_Occurred()) SWIG_fail;
31757 }
31758 resultobj = SWIG_Py_Void();
31759 return resultobj;
31760 fail:
31761 return NULL;
31762 }
31763
31764
31765 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31766 PyObject *resultobj = 0;
31767 wxWindow *arg1 = (wxWindow *) 0 ;
31768 void *argp1 = 0 ;
31769 int res1 = 0 ;
31770 PyObject *swig_obj[1] ;
31771
31772 if (!args) SWIG_fail;
31773 swig_obj[0] = args;
31774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31775 if (!SWIG_IsOK(res1)) {
31776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31777 }
31778 arg1 = reinterpret_cast< wxWindow * >(argp1);
31779 {
31780 PyThreadState* __tstate = wxPyBeginAllowThreads();
31781 (arg1)->Raise();
31782 wxPyEndAllowThreads(__tstate);
31783 if (PyErr_Occurred()) SWIG_fail;
31784 }
31785 resultobj = SWIG_Py_Void();
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31793 PyObject *resultobj = 0;
31794 wxWindow *arg1 = (wxWindow *) 0 ;
31795 void *argp1 = 0 ;
31796 int res1 = 0 ;
31797 PyObject *swig_obj[1] ;
31798
31799 if (!args) SWIG_fail;
31800 swig_obj[0] = args;
31801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31802 if (!SWIG_IsOK(res1)) {
31803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31804 }
31805 arg1 = reinterpret_cast< wxWindow * >(argp1);
31806 {
31807 PyThreadState* __tstate = wxPyBeginAllowThreads();
31808 (arg1)->Lower();
31809 wxPyEndAllowThreads(__tstate);
31810 if (PyErr_Occurred()) SWIG_fail;
31811 }
31812 resultobj = SWIG_Py_Void();
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj = 0;
31821 wxWindow *arg1 = (wxWindow *) 0 ;
31822 wxSize *arg2 = 0 ;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 wxSize temp2 ;
31826 PyObject * obj0 = 0 ;
31827 PyObject * obj1 = 0 ;
31828 char * kwnames[] = {
31829 (char *) "self",(char *) "size", NULL
31830 };
31831
31832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31836 }
31837 arg1 = reinterpret_cast< wxWindow * >(argp1);
31838 {
31839 arg2 = &temp2;
31840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31841 }
31842 {
31843 PyThreadState* __tstate = wxPyBeginAllowThreads();
31844 (arg1)->SetClientSize((wxSize const &)*arg2);
31845 wxPyEndAllowThreads(__tstate);
31846 if (PyErr_Occurred()) SWIG_fail;
31847 }
31848 resultobj = SWIG_Py_Void();
31849 return resultobj;
31850 fail:
31851 return NULL;
31852 }
31853
31854
31855 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31856 PyObject *resultobj = 0;
31857 wxWindow *arg1 = (wxWindow *) 0 ;
31858 int arg2 ;
31859 int arg3 ;
31860 void *argp1 = 0 ;
31861 int res1 = 0 ;
31862 int val2 ;
31863 int ecode2 = 0 ;
31864 int val3 ;
31865 int ecode3 = 0 ;
31866 PyObject * obj0 = 0 ;
31867 PyObject * obj1 = 0 ;
31868 PyObject * obj2 = 0 ;
31869 char * kwnames[] = {
31870 (char *) "self",(char *) "width",(char *) "height", NULL
31871 };
31872
31873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31875 if (!SWIG_IsOK(res1)) {
31876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31877 }
31878 arg1 = reinterpret_cast< wxWindow * >(argp1);
31879 ecode2 = SWIG_AsVal_int(obj1, &val2);
31880 if (!SWIG_IsOK(ecode2)) {
31881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31882 }
31883 arg2 = static_cast< int >(val2);
31884 ecode3 = SWIG_AsVal_int(obj2, &val3);
31885 if (!SWIG_IsOK(ecode3)) {
31886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31887 }
31888 arg3 = static_cast< int >(val3);
31889 {
31890 PyThreadState* __tstate = wxPyBeginAllowThreads();
31891 (arg1)->SetClientSize(arg2,arg3);
31892 wxPyEndAllowThreads(__tstate);
31893 if (PyErr_Occurred()) SWIG_fail;
31894 }
31895 resultobj = SWIG_Py_Void();
31896 return resultobj;
31897 fail:
31898 return NULL;
31899 }
31900
31901
31902 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31903 PyObject *resultobj = 0;
31904 wxWindow *arg1 = (wxWindow *) 0 ;
31905 wxRect *arg2 = 0 ;
31906 void *argp1 = 0 ;
31907 int res1 = 0 ;
31908 wxRect temp2 ;
31909 PyObject * obj0 = 0 ;
31910 PyObject * obj1 = 0 ;
31911 char * kwnames[] = {
31912 (char *) "self",(char *) "rect", NULL
31913 };
31914
31915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31919 }
31920 arg1 = reinterpret_cast< wxWindow * >(argp1);
31921 {
31922 arg2 = &temp2;
31923 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31924 }
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 (arg1)->SetClientSize((wxRect const &)*arg2);
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_Py_Void();
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31939 PyObject *resultobj = 0;
31940 wxWindow *arg1 = (wxWindow *) 0 ;
31941 wxPoint result;
31942 void *argp1 = 0 ;
31943 int res1 = 0 ;
31944 PyObject *swig_obj[1] ;
31945
31946 if (!args) SWIG_fail;
31947 swig_obj[0] = args;
31948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31949 if (!SWIG_IsOK(res1)) {
31950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31951 }
31952 arg1 = reinterpret_cast< wxWindow * >(argp1);
31953 {
31954 PyThreadState* __tstate = wxPyBeginAllowThreads();
31955 result = ((wxWindow const *)arg1)->GetPosition();
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31967 PyObject *resultobj = 0;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 int *arg2 = (int *) 0 ;
31970 int *arg3 = (int *) 0 ;
31971 void *argp1 = 0 ;
31972 int res1 = 0 ;
31973 int temp2 ;
31974 int res2 = SWIG_TMPOBJ ;
31975 int temp3 ;
31976 int res3 = SWIG_TMPOBJ ;
31977 PyObject *swig_obj[1] ;
31978
31979 arg2 = &temp2;
31980 arg3 = &temp3;
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_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31986 }
31987 arg1 = reinterpret_cast< wxWindow * >(argp1);
31988 {
31989 PyThreadState* __tstate = wxPyBeginAllowThreads();
31990 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31991 wxPyEndAllowThreads(__tstate);
31992 if (PyErr_Occurred()) SWIG_fail;
31993 }
31994 resultobj = SWIG_Py_Void();
31995 if (SWIG_IsTmpObj(res2)) {
31996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31997 } else {
31998 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32000 }
32001 if (SWIG_IsTmpObj(res3)) {
32002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32003 } else {
32004 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32006 }
32007 return resultobj;
32008 fail:
32009 return NULL;
32010 }
32011
32012
32013 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32014 PyObject *resultobj = 0;
32015 wxWindow *arg1 = (wxWindow *) 0 ;
32016 wxPoint result;
32017 void *argp1 = 0 ;
32018 int res1 = 0 ;
32019 PyObject *swig_obj[1] ;
32020
32021 if (!args) SWIG_fail;
32022 swig_obj[0] = args;
32023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32024 if (!SWIG_IsOK(res1)) {
32025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32026 }
32027 arg1 = reinterpret_cast< wxWindow * >(argp1);
32028 {
32029 PyThreadState* __tstate = wxPyBeginAllowThreads();
32030 result = ((wxWindow const *)arg1)->GetScreenPosition();
32031 wxPyEndAllowThreads(__tstate);
32032 if (PyErr_Occurred()) SWIG_fail;
32033 }
32034 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32035 return resultobj;
32036 fail:
32037 return NULL;
32038 }
32039
32040
32041 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32042 PyObject *resultobj = 0;
32043 wxWindow *arg1 = (wxWindow *) 0 ;
32044 int *arg2 = (int *) 0 ;
32045 int *arg3 = (int *) 0 ;
32046 void *argp1 = 0 ;
32047 int res1 = 0 ;
32048 int temp2 ;
32049 int res2 = SWIG_TMPOBJ ;
32050 int temp3 ;
32051 int res3 = SWIG_TMPOBJ ;
32052 PyObject *swig_obj[1] ;
32053
32054 arg2 = &temp2;
32055 arg3 = &temp3;
32056 if (!args) SWIG_fail;
32057 swig_obj[0] = args;
32058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32059 if (!SWIG_IsOK(res1)) {
32060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32061 }
32062 arg1 = reinterpret_cast< wxWindow * >(argp1);
32063 {
32064 PyThreadState* __tstate = wxPyBeginAllowThreads();
32065 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32066 wxPyEndAllowThreads(__tstate);
32067 if (PyErr_Occurred()) SWIG_fail;
32068 }
32069 resultobj = SWIG_Py_Void();
32070 if (SWIG_IsTmpObj(res2)) {
32071 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32072 } else {
32073 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32075 }
32076 if (SWIG_IsTmpObj(res3)) {
32077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32078 } else {
32079 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32081 }
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32089 PyObject *resultobj = 0;
32090 wxWindow *arg1 = (wxWindow *) 0 ;
32091 wxRect result;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 PyObject *swig_obj[1] ;
32095
32096 if (!args) SWIG_fail;
32097 swig_obj[0] = args;
32098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32099 if (!SWIG_IsOK(res1)) {
32100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32101 }
32102 arg1 = reinterpret_cast< wxWindow * >(argp1);
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 result = ((wxWindow const *)arg1)->GetScreenRect();
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 wxWindow *arg1 = (wxWindow *) 0 ;
32119 wxSize result;
32120 void *argp1 = 0 ;
32121 int res1 = 0 ;
32122 PyObject *swig_obj[1] ;
32123
32124 if (!args) SWIG_fail;
32125 swig_obj[0] = args;
32126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32129 }
32130 arg1 = reinterpret_cast< wxWindow * >(argp1);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = ((wxWindow const *)arg1)->GetSize();
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 int *arg2 = (int *) 0 ;
32148 int *arg3 = (int *) 0 ;
32149 void *argp1 = 0 ;
32150 int res1 = 0 ;
32151 int temp2 ;
32152 int res2 = SWIG_TMPOBJ ;
32153 int temp3 ;
32154 int res3 = SWIG_TMPOBJ ;
32155 PyObject *swig_obj[1] ;
32156
32157 arg2 = &temp2;
32158 arg3 = &temp3;
32159 if (!args) SWIG_fail;
32160 swig_obj[0] = args;
32161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32162 if (!SWIG_IsOK(res1)) {
32163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32164 }
32165 arg1 = reinterpret_cast< wxWindow * >(argp1);
32166 {
32167 PyThreadState* __tstate = wxPyBeginAllowThreads();
32168 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32169 wxPyEndAllowThreads(__tstate);
32170 if (PyErr_Occurred()) SWIG_fail;
32171 }
32172 resultobj = SWIG_Py_Void();
32173 if (SWIG_IsTmpObj(res2)) {
32174 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32175 } else {
32176 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32177 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32178 }
32179 if (SWIG_IsTmpObj(res3)) {
32180 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32181 } else {
32182 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32183 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32184 }
32185 return resultobj;
32186 fail:
32187 return NULL;
32188 }
32189
32190
32191 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32192 PyObject *resultobj = 0;
32193 wxWindow *arg1 = (wxWindow *) 0 ;
32194 wxRect result;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 PyObject *swig_obj[1] ;
32198
32199 if (!args) SWIG_fail;
32200 swig_obj[0] = args;
32201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32202 if (!SWIG_IsOK(res1)) {
32203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32204 }
32205 arg1 = reinterpret_cast< wxWindow * >(argp1);
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 result = ((wxWindow const *)arg1)->GetRect();
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 wxSize result;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 PyObject *swig_obj[1] ;
32226
32227 if (!args) SWIG_fail;
32228 swig_obj[0] = args;
32229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32230 if (!SWIG_IsOK(res1)) {
32231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32232 }
32233 arg1 = reinterpret_cast< wxWindow * >(argp1);
32234 {
32235 PyThreadState* __tstate = wxPyBeginAllowThreads();
32236 result = ((wxWindow const *)arg1)->GetClientSize();
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32241 return resultobj;
32242 fail:
32243 return NULL;
32244 }
32245
32246
32247 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32248 PyObject *resultobj = 0;
32249 wxWindow *arg1 = (wxWindow *) 0 ;
32250 int *arg2 = (int *) 0 ;
32251 int *arg3 = (int *) 0 ;
32252 void *argp1 = 0 ;
32253 int res1 = 0 ;
32254 int temp2 ;
32255 int res2 = SWIG_TMPOBJ ;
32256 int temp3 ;
32257 int res3 = SWIG_TMPOBJ ;
32258 PyObject *swig_obj[1] ;
32259
32260 arg2 = &temp2;
32261 arg3 = &temp3;
32262 if (!args) SWIG_fail;
32263 swig_obj[0] = args;
32264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32265 if (!SWIG_IsOK(res1)) {
32266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32267 }
32268 arg1 = reinterpret_cast< wxWindow * >(argp1);
32269 {
32270 PyThreadState* __tstate = wxPyBeginAllowThreads();
32271 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32272 wxPyEndAllowThreads(__tstate);
32273 if (PyErr_Occurred()) SWIG_fail;
32274 }
32275 resultobj = SWIG_Py_Void();
32276 if (SWIG_IsTmpObj(res2)) {
32277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32278 } else {
32279 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32281 }
32282 if (SWIG_IsTmpObj(res3)) {
32283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32284 } else {
32285 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32287 }
32288 return resultobj;
32289 fail:
32290 return NULL;
32291 }
32292
32293
32294 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32295 PyObject *resultobj = 0;
32296 wxWindow *arg1 = (wxWindow *) 0 ;
32297 wxPoint result;
32298 void *argp1 = 0 ;
32299 int res1 = 0 ;
32300 PyObject *swig_obj[1] ;
32301
32302 if (!args) SWIG_fail;
32303 swig_obj[0] = args;
32304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32307 }
32308 arg1 = reinterpret_cast< wxWindow * >(argp1);
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32316 return resultobj;
32317 fail:
32318 return NULL;
32319 }
32320
32321
32322 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 PyObject *resultobj = 0;
32324 wxWindow *arg1 = (wxWindow *) 0 ;
32325 wxRect result;
32326 void *argp1 = 0 ;
32327 int res1 = 0 ;
32328 PyObject *swig_obj[1] ;
32329
32330 if (!args) SWIG_fail;
32331 swig_obj[0] = args;
32332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32333 if (!SWIG_IsOK(res1)) {
32334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32335 }
32336 arg1 = reinterpret_cast< wxWindow * >(argp1);
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 result = ((wxWindow const *)arg1)->GetClientRect();
32340 wxPyEndAllowThreads(__tstate);
32341 if (PyErr_Occurred()) SWIG_fail;
32342 }
32343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32344 return resultobj;
32345 fail:
32346 return NULL;
32347 }
32348
32349
32350 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32351 PyObject *resultobj = 0;
32352 wxWindow *arg1 = (wxWindow *) 0 ;
32353 wxSize result;
32354 void *argp1 = 0 ;
32355 int res1 = 0 ;
32356 PyObject *swig_obj[1] ;
32357
32358 if (!args) SWIG_fail;
32359 swig_obj[0] = args;
32360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32361 if (!SWIG_IsOK(res1)) {
32362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32363 }
32364 arg1 = reinterpret_cast< wxWindow * >(argp1);
32365 {
32366 PyThreadState* __tstate = wxPyBeginAllowThreads();
32367 result = ((wxWindow const *)arg1)->GetBestSize();
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32379 PyObject *resultobj = 0;
32380 wxWindow *arg1 = (wxWindow *) 0 ;
32381 int *arg2 = (int *) 0 ;
32382 int *arg3 = (int *) 0 ;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 int temp2 ;
32386 int res2 = SWIG_TMPOBJ ;
32387 int temp3 ;
32388 int res3 = SWIG_TMPOBJ ;
32389 PyObject *swig_obj[1] ;
32390
32391 arg2 = &temp2;
32392 arg3 = &temp3;
32393 if (!args) SWIG_fail;
32394 swig_obj[0] = args;
32395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32396 if (!SWIG_IsOK(res1)) {
32397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32398 }
32399 arg1 = reinterpret_cast< wxWindow * >(argp1);
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_Py_Void();
32407 if (SWIG_IsTmpObj(res2)) {
32408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32409 } else {
32410 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32411 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32412 }
32413 if (SWIG_IsTmpObj(res3)) {
32414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32415 } else {
32416 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32418 }
32419 return resultobj;
32420 fail:
32421 return NULL;
32422 }
32423
32424
32425 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 PyObject *resultobj = 0;
32427 wxWindow *arg1 = (wxWindow *) 0 ;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject *swig_obj[1] ;
32431
32432 if (!args) SWIG_fail;
32433 swig_obj[0] = args;
32434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32437 }
32438 arg1 = reinterpret_cast< wxWindow * >(argp1);
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 (arg1)->InvalidateBestSize();
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 resultobj = SWIG_Py_Void();
32446 return resultobj;
32447 fail:
32448 return NULL;
32449 }
32450
32451
32452 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32453 PyObject *resultobj = 0;
32454 wxWindow *arg1 = (wxWindow *) 0 ;
32455 wxSize *arg2 = 0 ;
32456 void *argp1 = 0 ;
32457 int res1 = 0 ;
32458 wxSize temp2 ;
32459 PyObject * obj0 = 0 ;
32460 PyObject * obj1 = 0 ;
32461 char * kwnames[] = {
32462 (char *) "self",(char *) "size", NULL
32463 };
32464
32465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32467 if (!SWIG_IsOK(res1)) {
32468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32469 }
32470 arg1 = reinterpret_cast< wxWindow * >(argp1);
32471 {
32472 arg2 = &temp2;
32473 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32474 }
32475 {
32476 PyThreadState* __tstate = wxPyBeginAllowThreads();
32477 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32478 wxPyEndAllowThreads(__tstate);
32479 if (PyErr_Occurred()) SWIG_fail;
32480 }
32481 resultobj = SWIG_Py_Void();
32482 return resultobj;
32483 fail:
32484 return NULL;
32485 }
32486
32487
32488 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32489 PyObject *resultobj = 0;
32490 wxWindow *arg1 = (wxWindow *) 0 ;
32491 wxSize result;
32492 void *argp1 = 0 ;
32493 int res1 = 0 ;
32494 PyObject *swig_obj[1] ;
32495
32496 if (!args) SWIG_fail;
32497 swig_obj[0] = args;
32498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32499 if (!SWIG_IsOK(res1)) {
32500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32501 }
32502 arg1 = reinterpret_cast< wxWindow * >(argp1);
32503 {
32504 PyThreadState* __tstate = wxPyBeginAllowThreads();
32505 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32506 wxPyEndAllowThreads(__tstate);
32507 if (PyErr_Occurred()) SWIG_fail;
32508 }
32509 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxWindow *arg1 = (wxWindow *) 0 ;
32519 wxSize result;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 PyObject *swig_obj[1] ;
32523
32524 if (!args) SWIG_fail;
32525 swig_obj[0] = args;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32529 }
32530 arg1 = reinterpret_cast< wxWindow * >(argp1);
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj = 0;
32546 wxWindow *arg1 = (wxWindow *) 0 ;
32547 int arg2 = (int) wxBOTH ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 int val2 ;
32551 int ecode2 = 0 ;
32552 PyObject * obj0 = 0 ;
32553 PyObject * obj1 = 0 ;
32554 char * kwnames[] = {
32555 (char *) "self",(char *) "direction", NULL
32556 };
32557
32558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32560 if (!SWIG_IsOK(res1)) {
32561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32562 }
32563 arg1 = reinterpret_cast< wxWindow * >(argp1);
32564 if (obj1) {
32565 ecode2 = SWIG_AsVal_int(obj1, &val2);
32566 if (!SWIG_IsOK(ecode2)) {
32567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32568 }
32569 arg2 = static_cast< int >(val2);
32570 }
32571 {
32572 PyThreadState* __tstate = wxPyBeginAllowThreads();
32573 (arg1)->Center(arg2);
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 resultobj = SWIG_Py_Void();
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32585 PyObject *resultobj = 0;
32586 wxWindow *arg1 = (wxWindow *) 0 ;
32587 int arg2 = (int) wxBOTH ;
32588 void *argp1 = 0 ;
32589 int res1 = 0 ;
32590 int val2 ;
32591 int ecode2 = 0 ;
32592 PyObject * obj0 = 0 ;
32593 PyObject * obj1 = 0 ;
32594 char * kwnames[] = {
32595 (char *) "self",(char *) "dir", NULL
32596 };
32597
32598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32600 if (!SWIG_IsOK(res1)) {
32601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32602 }
32603 arg1 = reinterpret_cast< wxWindow * >(argp1);
32604 if (obj1) {
32605 ecode2 = SWIG_AsVal_int(obj1, &val2);
32606 if (!SWIG_IsOK(ecode2)) {
32607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32608 }
32609 arg2 = static_cast< int >(val2);
32610 }
32611 {
32612 PyThreadState* __tstate = wxPyBeginAllowThreads();
32613 (arg1)->CenterOnParent(arg2);
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 resultobj = SWIG_Py_Void();
32618 return resultobj;
32619 fail:
32620 return NULL;
32621 }
32622
32623
32624 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32625 PyObject *resultobj = 0;
32626 wxWindow *arg1 = (wxWindow *) 0 ;
32627 void *argp1 = 0 ;
32628 int res1 = 0 ;
32629 PyObject *swig_obj[1] ;
32630
32631 if (!args) SWIG_fail;
32632 swig_obj[0] = args;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32636 }
32637 arg1 = reinterpret_cast< wxWindow * >(argp1);
32638 {
32639 PyThreadState* __tstate = wxPyBeginAllowThreads();
32640 (arg1)->Fit();
32641 wxPyEndAllowThreads(__tstate);
32642 if (PyErr_Occurred()) SWIG_fail;
32643 }
32644 resultobj = SWIG_Py_Void();
32645 return resultobj;
32646 fail:
32647 return NULL;
32648 }
32649
32650
32651 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32652 PyObject *resultobj = 0;
32653 wxWindow *arg1 = (wxWindow *) 0 ;
32654 void *argp1 = 0 ;
32655 int res1 = 0 ;
32656 PyObject *swig_obj[1] ;
32657
32658 if (!args) SWIG_fail;
32659 swig_obj[0] = args;
32660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32661 if (!SWIG_IsOK(res1)) {
32662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32663 }
32664 arg1 = reinterpret_cast< wxWindow * >(argp1);
32665 {
32666 PyThreadState* __tstate = wxPyBeginAllowThreads();
32667 (arg1)->FitInside();
32668 wxPyEndAllowThreads(__tstate);
32669 if (PyErr_Occurred()) SWIG_fail;
32670 }
32671 resultobj = SWIG_Py_Void();
32672 return resultobj;
32673 fail:
32674 return NULL;
32675 }
32676
32677
32678 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32679 PyObject *resultobj = 0;
32680 wxWindow *arg1 = (wxWindow *) 0 ;
32681 int arg2 ;
32682 int arg3 ;
32683 int arg4 = (int) -1 ;
32684 int arg5 = (int) -1 ;
32685 int arg6 = (int) -1 ;
32686 int arg7 = (int) -1 ;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 int val2 ;
32690 int ecode2 = 0 ;
32691 int val3 ;
32692 int ecode3 = 0 ;
32693 int val4 ;
32694 int ecode4 = 0 ;
32695 int val5 ;
32696 int ecode5 = 0 ;
32697 int val6 ;
32698 int ecode6 = 0 ;
32699 int val7 ;
32700 int ecode7 = 0 ;
32701 PyObject * obj0 = 0 ;
32702 PyObject * obj1 = 0 ;
32703 PyObject * obj2 = 0 ;
32704 PyObject * obj3 = 0 ;
32705 PyObject * obj4 = 0 ;
32706 PyObject * obj5 = 0 ;
32707 PyObject * obj6 = 0 ;
32708 char * kwnames[] = {
32709 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32710 };
32711
32712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32714 if (!SWIG_IsOK(res1)) {
32715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32716 }
32717 arg1 = reinterpret_cast< wxWindow * >(argp1);
32718 ecode2 = SWIG_AsVal_int(obj1, &val2);
32719 if (!SWIG_IsOK(ecode2)) {
32720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32721 }
32722 arg2 = static_cast< int >(val2);
32723 ecode3 = SWIG_AsVal_int(obj2, &val3);
32724 if (!SWIG_IsOK(ecode3)) {
32725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32726 }
32727 arg3 = static_cast< int >(val3);
32728 if (obj3) {
32729 ecode4 = SWIG_AsVal_int(obj3, &val4);
32730 if (!SWIG_IsOK(ecode4)) {
32731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32732 }
32733 arg4 = static_cast< int >(val4);
32734 }
32735 if (obj4) {
32736 ecode5 = SWIG_AsVal_int(obj4, &val5);
32737 if (!SWIG_IsOK(ecode5)) {
32738 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32739 }
32740 arg5 = static_cast< int >(val5);
32741 }
32742 if (obj5) {
32743 ecode6 = SWIG_AsVal_int(obj5, &val6);
32744 if (!SWIG_IsOK(ecode6)) {
32745 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32746 }
32747 arg6 = static_cast< int >(val6);
32748 }
32749 if (obj6) {
32750 ecode7 = SWIG_AsVal_int(obj6, &val7);
32751 if (!SWIG_IsOK(ecode7)) {
32752 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32753 }
32754 arg7 = static_cast< int >(val7);
32755 }
32756 {
32757 PyThreadState* __tstate = wxPyBeginAllowThreads();
32758 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32759 wxPyEndAllowThreads(__tstate);
32760 if (PyErr_Occurred()) SWIG_fail;
32761 }
32762 resultobj = SWIG_Py_Void();
32763 return resultobj;
32764 fail:
32765 return NULL;
32766 }
32767
32768
32769 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32770 PyObject *resultobj = 0;
32771 wxWindow *arg1 = (wxWindow *) 0 ;
32772 wxSize *arg2 = 0 ;
32773 wxSize const &arg3_defvalue = wxDefaultSize ;
32774 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32775 wxSize const &arg4_defvalue = wxDefaultSize ;
32776 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32777 void *argp1 = 0 ;
32778 int res1 = 0 ;
32779 wxSize temp2 ;
32780 wxSize temp3 ;
32781 wxSize temp4 ;
32782 PyObject * obj0 = 0 ;
32783 PyObject * obj1 = 0 ;
32784 PyObject * obj2 = 0 ;
32785 PyObject * obj3 = 0 ;
32786 char * kwnames[] = {
32787 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32788 };
32789
32790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32792 if (!SWIG_IsOK(res1)) {
32793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32794 }
32795 arg1 = reinterpret_cast< wxWindow * >(argp1);
32796 {
32797 arg2 = &temp2;
32798 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32799 }
32800 if (obj2) {
32801 {
32802 arg3 = &temp3;
32803 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32804 }
32805 }
32806 if (obj3) {
32807 {
32808 arg4 = &temp4;
32809 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32810 }
32811 }
32812 {
32813 PyThreadState* __tstate = wxPyBeginAllowThreads();
32814 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
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_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32826 PyObject *resultobj = 0;
32827 wxWindow *arg1 = (wxWindow *) 0 ;
32828 int arg2 ;
32829 int arg3 ;
32830 int arg4 = (int) -1 ;
32831 int arg5 = (int) -1 ;
32832 void *argp1 = 0 ;
32833 int res1 = 0 ;
32834 int val2 ;
32835 int ecode2 = 0 ;
32836 int val3 ;
32837 int ecode3 = 0 ;
32838 int val4 ;
32839 int ecode4 = 0 ;
32840 int val5 ;
32841 int ecode5 = 0 ;
32842 PyObject * obj0 = 0 ;
32843 PyObject * obj1 = 0 ;
32844 PyObject * obj2 = 0 ;
32845 PyObject * obj3 = 0 ;
32846 PyObject * obj4 = 0 ;
32847 char * kwnames[] = {
32848 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32849 };
32850
32851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res1)) {
32854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32855 }
32856 arg1 = reinterpret_cast< wxWindow * >(argp1);
32857 ecode2 = SWIG_AsVal_int(obj1, &val2);
32858 if (!SWIG_IsOK(ecode2)) {
32859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32860 }
32861 arg2 = static_cast< int >(val2);
32862 ecode3 = SWIG_AsVal_int(obj2, &val3);
32863 if (!SWIG_IsOK(ecode3)) {
32864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32865 }
32866 arg3 = static_cast< int >(val3);
32867 if (obj3) {
32868 ecode4 = SWIG_AsVal_int(obj3, &val4);
32869 if (!SWIG_IsOK(ecode4)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32871 }
32872 arg4 = static_cast< int >(val4);
32873 }
32874 if (obj4) {
32875 ecode5 = SWIG_AsVal_int(obj4, &val5);
32876 if (!SWIG_IsOK(ecode5)) {
32877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32878 }
32879 arg5 = static_cast< int >(val5);
32880 }
32881 {
32882 PyThreadState* __tstate = wxPyBeginAllowThreads();
32883 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32884 wxPyEndAllowThreads(__tstate);
32885 if (PyErr_Occurred()) SWIG_fail;
32886 }
32887 resultobj = SWIG_Py_Void();
32888 return resultobj;
32889 fail:
32890 return NULL;
32891 }
32892
32893
32894 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32895 PyObject *resultobj = 0;
32896 wxWindow *arg1 = (wxWindow *) 0 ;
32897 wxSize *arg2 = 0 ;
32898 wxSize const &arg3_defvalue = wxDefaultSize ;
32899 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32900 void *argp1 = 0 ;
32901 int res1 = 0 ;
32902 wxSize temp2 ;
32903 wxSize temp3 ;
32904 PyObject * obj0 = 0 ;
32905 PyObject * obj1 = 0 ;
32906 PyObject * obj2 = 0 ;
32907 char * kwnames[] = {
32908 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32909 };
32910
32911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32913 if (!SWIG_IsOK(res1)) {
32914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32915 }
32916 arg1 = reinterpret_cast< wxWindow * >(argp1);
32917 {
32918 arg2 = &temp2;
32919 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32920 }
32921 if (obj2) {
32922 {
32923 arg3 = &temp3;
32924 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32925 }
32926 }
32927 {
32928 PyThreadState* __tstate = wxPyBeginAllowThreads();
32929 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 resultobj = SWIG_Py_Void();
32934 return resultobj;
32935 fail:
32936 return NULL;
32937 }
32938
32939
32940 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32941 PyObject *resultobj = 0;
32942 wxWindow *arg1 = (wxWindow *) 0 ;
32943 wxSize result;
32944 void *argp1 = 0 ;
32945 int res1 = 0 ;
32946 PyObject *swig_obj[1] ;
32947
32948 if (!args) SWIG_fail;
32949 swig_obj[0] = args;
32950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32951 if (!SWIG_IsOK(res1)) {
32952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32953 }
32954 arg1 = reinterpret_cast< wxWindow * >(argp1);
32955 {
32956 PyThreadState* __tstate = wxPyBeginAllowThreads();
32957 result = ((wxWindow const *)arg1)->GetMaxSize();
32958 wxPyEndAllowThreads(__tstate);
32959 if (PyErr_Occurred()) SWIG_fail;
32960 }
32961 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32962 return resultobj;
32963 fail:
32964 return NULL;
32965 }
32966
32967
32968 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32969 PyObject *resultobj = 0;
32970 wxWindow *arg1 = (wxWindow *) 0 ;
32971 wxSize result;
32972 void *argp1 = 0 ;
32973 int res1 = 0 ;
32974 PyObject *swig_obj[1] ;
32975
32976 if (!args) SWIG_fail;
32977 swig_obj[0] = args;
32978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32979 if (!SWIG_IsOK(res1)) {
32980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32981 }
32982 arg1 = reinterpret_cast< wxWindow * >(argp1);
32983 {
32984 PyThreadState* __tstate = wxPyBeginAllowThreads();
32985 result = ((wxWindow const *)arg1)->GetMinSize();
32986 wxPyEndAllowThreads(__tstate);
32987 if (PyErr_Occurred()) SWIG_fail;
32988 }
32989 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 wxSize *arg2 = 0 ;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 wxSize temp2 ;
33003 PyObject * obj0 = 0 ;
33004 PyObject * obj1 = 0 ;
33005 char * kwnames[] = {
33006 (char *) "self",(char *) "minSize", NULL
33007 };
33008
33009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33011 if (!SWIG_IsOK(res1)) {
33012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33013 }
33014 arg1 = reinterpret_cast< wxWindow * >(argp1);
33015 {
33016 arg2 = &temp2;
33017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33018 }
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 (arg1)->SetMinSize((wxSize const &)*arg2);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 resultobj = SWIG_Py_Void();
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33033 PyObject *resultobj = 0;
33034 wxWindow *arg1 = (wxWindow *) 0 ;
33035 wxSize *arg2 = 0 ;
33036 void *argp1 = 0 ;
33037 int res1 = 0 ;
33038 wxSize temp2 ;
33039 PyObject * obj0 = 0 ;
33040 PyObject * obj1 = 0 ;
33041 char * kwnames[] = {
33042 (char *) "self",(char *) "maxSize", NULL
33043 };
33044
33045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33047 if (!SWIG_IsOK(res1)) {
33048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33049 }
33050 arg1 = reinterpret_cast< wxWindow * >(argp1);
33051 {
33052 arg2 = &temp2;
33053 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 (arg1)->SetMaxSize((wxSize const &)*arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 resultobj = SWIG_Py_Void();
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxWindow *arg1 = (wxWindow *) 0 ;
33071 int result;
33072 void *argp1 = 0 ;
33073 int res1 = 0 ;
33074 PyObject *swig_obj[1] ;
33075
33076 if (!args) SWIG_fail;
33077 swig_obj[0] = args;
33078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33081 }
33082 arg1 = reinterpret_cast< wxWindow * >(argp1);
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 resultobj = SWIG_From_int(static_cast< int >(result));
33090 return resultobj;
33091 fail:
33092 return NULL;
33093 }
33094
33095
33096 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33097 PyObject *resultobj = 0;
33098 wxWindow *arg1 = (wxWindow *) 0 ;
33099 int result;
33100 void *argp1 = 0 ;
33101 int res1 = 0 ;
33102 PyObject *swig_obj[1] ;
33103
33104 if (!args) SWIG_fail;
33105 swig_obj[0] = args;
33106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33107 if (!SWIG_IsOK(res1)) {
33108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33109 }
33110 arg1 = reinterpret_cast< wxWindow * >(argp1);
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33114 wxPyEndAllowThreads(__tstate);
33115 if (PyErr_Occurred()) SWIG_fail;
33116 }
33117 resultobj = SWIG_From_int(static_cast< int >(result));
33118 return resultobj;
33119 fail:
33120 return NULL;
33121 }
33122
33123
33124 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33125 PyObject *resultobj = 0;
33126 wxWindow *arg1 = (wxWindow *) 0 ;
33127 int result;
33128 void *argp1 = 0 ;
33129 int res1 = 0 ;
33130 PyObject *swig_obj[1] ;
33131
33132 if (!args) SWIG_fail;
33133 swig_obj[0] = args;
33134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33135 if (!SWIG_IsOK(res1)) {
33136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33137 }
33138 arg1 = reinterpret_cast< wxWindow * >(argp1);
33139 {
33140 PyThreadState* __tstate = wxPyBeginAllowThreads();
33141 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 resultobj = SWIG_From_int(static_cast< int >(result));
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 int result;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 PyObject *swig_obj[1] ;
33159
33160 if (!args) SWIG_fail;
33161 swig_obj[0] = args;
33162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 {
33168 PyThreadState* __tstate = wxPyBeginAllowThreads();
33169 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33170 wxPyEndAllowThreads(__tstate);
33171 if (PyErr_Occurred()) SWIG_fail;
33172 }
33173 resultobj = SWIG_From_int(static_cast< int >(result));
33174 return resultobj;
33175 fail:
33176 return NULL;
33177 }
33178
33179
33180 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33181 PyObject *resultobj = 0;
33182 wxWindow *arg1 = (wxWindow *) 0 ;
33183 wxSize *arg2 = 0 ;
33184 void *argp1 = 0 ;
33185 int res1 = 0 ;
33186 wxSize temp2 ;
33187 PyObject * obj0 = 0 ;
33188 PyObject * obj1 = 0 ;
33189 char * kwnames[] = {
33190 (char *) "self",(char *) "size", NULL
33191 };
33192
33193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33195 if (!SWIG_IsOK(res1)) {
33196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33197 }
33198 arg1 = reinterpret_cast< wxWindow * >(argp1);
33199 {
33200 arg2 = &temp2;
33201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33202 }
33203 {
33204 PyThreadState* __tstate = wxPyBeginAllowThreads();
33205 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33206 wxPyEndAllowThreads(__tstate);
33207 if (PyErr_Occurred()) SWIG_fail;
33208 }
33209 resultobj = SWIG_Py_Void();
33210 return resultobj;
33211 fail:
33212 return NULL;
33213 }
33214
33215
33216 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33217 PyObject *resultobj = 0;
33218 wxWindow *arg1 = (wxWindow *) 0 ;
33219 int arg2 ;
33220 int arg3 ;
33221 void *argp1 = 0 ;
33222 int res1 = 0 ;
33223 int val2 ;
33224 int ecode2 = 0 ;
33225 int val3 ;
33226 int ecode3 = 0 ;
33227 PyObject * obj0 = 0 ;
33228 PyObject * obj1 = 0 ;
33229 PyObject * obj2 = 0 ;
33230 char * kwnames[] = {
33231 (char *) "self",(char *) "w",(char *) "h", NULL
33232 };
33233
33234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33236 if (!SWIG_IsOK(res1)) {
33237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33238 }
33239 arg1 = reinterpret_cast< wxWindow * >(argp1);
33240 ecode2 = SWIG_AsVal_int(obj1, &val2);
33241 if (!SWIG_IsOK(ecode2)) {
33242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33243 }
33244 arg2 = static_cast< int >(val2);
33245 ecode3 = SWIG_AsVal_int(obj2, &val3);
33246 if (!SWIG_IsOK(ecode3)) {
33247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33248 }
33249 arg3 = static_cast< int >(val3);
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 (arg1)->SetVirtualSize(arg2,arg3);
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 resultobj = SWIG_Py_Void();
33257 return resultobj;
33258 fail:
33259 return NULL;
33260 }
33261
33262
33263 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33264 PyObject *resultobj = 0;
33265 wxWindow *arg1 = (wxWindow *) 0 ;
33266 wxSize result;
33267 void *argp1 = 0 ;
33268 int res1 = 0 ;
33269 PyObject *swig_obj[1] ;
33270
33271 if (!args) SWIG_fail;
33272 swig_obj[0] = args;
33273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33274 if (!SWIG_IsOK(res1)) {
33275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33276 }
33277 arg1 = reinterpret_cast< wxWindow * >(argp1);
33278 {
33279 PyThreadState* __tstate = wxPyBeginAllowThreads();
33280 result = ((wxWindow const *)arg1)->GetVirtualSize();
33281 wxPyEndAllowThreads(__tstate);
33282 if (PyErr_Occurred()) SWIG_fail;
33283 }
33284 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33292 PyObject *resultobj = 0;
33293 wxWindow *arg1 = (wxWindow *) 0 ;
33294 int *arg2 = (int *) 0 ;
33295 int *arg3 = (int *) 0 ;
33296 void *argp1 = 0 ;
33297 int res1 = 0 ;
33298 int temp2 ;
33299 int res2 = SWIG_TMPOBJ ;
33300 int temp3 ;
33301 int res3 = SWIG_TMPOBJ ;
33302 PyObject *swig_obj[1] ;
33303
33304 arg2 = &temp2;
33305 arg3 = &temp3;
33306 if (!args) SWIG_fail;
33307 swig_obj[0] = args;
33308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33309 if (!SWIG_IsOK(res1)) {
33310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33311 }
33312 arg1 = reinterpret_cast< wxWindow * >(argp1);
33313 {
33314 PyThreadState* __tstate = wxPyBeginAllowThreads();
33315 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33316 wxPyEndAllowThreads(__tstate);
33317 if (PyErr_Occurred()) SWIG_fail;
33318 }
33319 resultobj = SWIG_Py_Void();
33320 if (SWIG_IsTmpObj(res2)) {
33321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33322 } else {
33323 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33325 }
33326 if (SWIG_IsTmpObj(res3)) {
33327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33328 } else {
33329 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33331 }
33332 return resultobj;
33333 fail:
33334 return NULL;
33335 }
33336
33337
33338 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33339 PyObject *resultobj = 0;
33340 wxWindow *arg1 = (wxWindow *) 0 ;
33341 wxSize result;
33342 void *argp1 = 0 ;
33343 int res1 = 0 ;
33344 PyObject *swig_obj[1] ;
33345
33346 if (!args) SWIG_fail;
33347 swig_obj[0] = args;
33348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33349 if (!SWIG_IsOK(res1)) {
33350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33351 }
33352 arg1 = reinterpret_cast< wxWindow * >(argp1);
33353 {
33354 PyThreadState* __tstate = wxPyBeginAllowThreads();
33355 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33356 wxPyEndAllowThreads(__tstate);
33357 if (PyErr_Occurred()) SWIG_fail;
33358 }
33359 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj = 0;
33368 wxWindow *arg1 = (wxWindow *) 0 ;
33369 bool arg2 = (bool) true ;
33370 bool result;
33371 void *argp1 = 0 ;
33372 int res1 = 0 ;
33373 bool val2 ;
33374 int ecode2 = 0 ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 char * kwnames[] = {
33378 (char *) "self",(char *) "show", NULL
33379 };
33380
33381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33383 if (!SWIG_IsOK(res1)) {
33384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33385 }
33386 arg1 = reinterpret_cast< wxWindow * >(argp1);
33387 if (obj1) {
33388 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33389 if (!SWIG_IsOK(ecode2)) {
33390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33391 }
33392 arg2 = static_cast< bool >(val2);
33393 }
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 result = (bool)(arg1)->Show(arg2);
33397 wxPyEndAllowThreads(__tstate);
33398 if (PyErr_Occurred()) SWIG_fail;
33399 }
33400 {
33401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33402 }
33403 return resultobj;
33404 fail:
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33410 PyObject *resultobj = 0;
33411 wxWindow *arg1 = (wxWindow *) 0 ;
33412 bool result;
33413 void *argp1 = 0 ;
33414 int res1 = 0 ;
33415 PyObject *swig_obj[1] ;
33416
33417 if (!args) SWIG_fail;
33418 swig_obj[0] = args;
33419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33420 if (!SWIG_IsOK(res1)) {
33421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33422 }
33423 arg1 = reinterpret_cast< wxWindow * >(argp1);
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 result = (bool)(arg1)->Hide();
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 {
33431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33432 }
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 bool arg2 = (bool) true ;
33443 bool result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 bool val2 ;
33447 int ecode2 = 0 ;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 char * kwnames[] = {
33451 (char *) "self",(char *) "enable", NULL
33452 };
33453
33454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33456 if (!SWIG_IsOK(res1)) {
33457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33458 }
33459 arg1 = reinterpret_cast< wxWindow * >(argp1);
33460 if (obj1) {
33461 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33462 if (!SWIG_IsOK(ecode2)) {
33463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33464 }
33465 arg2 = static_cast< bool >(val2);
33466 }
33467 {
33468 PyThreadState* __tstate = wxPyBeginAllowThreads();
33469 result = (bool)(arg1)->Enable(arg2);
33470 wxPyEndAllowThreads(__tstate);
33471 if (PyErr_Occurred()) SWIG_fail;
33472 }
33473 {
33474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33475 }
33476 return resultobj;
33477 fail:
33478 return NULL;
33479 }
33480
33481
33482 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33483 PyObject *resultobj = 0;
33484 wxWindow *arg1 = (wxWindow *) 0 ;
33485 bool result;
33486 void *argp1 = 0 ;
33487 int res1 = 0 ;
33488 PyObject *swig_obj[1] ;
33489
33490 if (!args) SWIG_fail;
33491 swig_obj[0] = args;
33492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33493 if (!SWIG_IsOK(res1)) {
33494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33495 }
33496 arg1 = reinterpret_cast< wxWindow * >(argp1);
33497 {
33498 PyThreadState* __tstate = wxPyBeginAllowThreads();
33499 result = (bool)(arg1)->Disable();
33500 wxPyEndAllowThreads(__tstate);
33501 if (PyErr_Occurred()) SWIG_fail;
33502 }
33503 {
33504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33505 }
33506 return resultobj;
33507 fail:
33508 return NULL;
33509 }
33510
33511
33512 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33513 PyObject *resultobj = 0;
33514 wxWindow *arg1 = (wxWindow *) 0 ;
33515 bool result;
33516 void *argp1 = 0 ;
33517 int res1 = 0 ;
33518 PyObject *swig_obj[1] ;
33519
33520 if (!args) SWIG_fail;
33521 swig_obj[0] = args;
33522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33523 if (!SWIG_IsOK(res1)) {
33524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33525 }
33526 arg1 = reinterpret_cast< wxWindow * >(argp1);
33527 {
33528 PyThreadState* __tstate = wxPyBeginAllowThreads();
33529 result = (bool)((wxWindow const *)arg1)->IsShown();
33530 wxPyEndAllowThreads(__tstate);
33531 if (PyErr_Occurred()) SWIG_fail;
33532 }
33533 {
33534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33535 }
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33543 PyObject *resultobj = 0;
33544 wxWindow *arg1 = (wxWindow *) 0 ;
33545 bool result;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 PyObject *swig_obj[1] ;
33549
33550 if (!args) SWIG_fail;
33551 swig_obj[0] = args;
33552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33555 }
33556 arg1 = reinterpret_cast< wxWindow * >(argp1);
33557 {
33558 PyThreadState* __tstate = wxPyBeginAllowThreads();
33559 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33560 wxPyEndAllowThreads(__tstate);
33561 if (PyErr_Occurred()) SWIG_fail;
33562 }
33563 {
33564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33565 }
33566 return resultobj;
33567 fail:
33568 return NULL;
33569 }
33570
33571
33572 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33573 PyObject *resultobj = 0;
33574 wxWindow *arg1 = (wxWindow *) 0 ;
33575 bool result;
33576 void *argp1 = 0 ;
33577 int res1 = 0 ;
33578 PyObject *swig_obj[1] ;
33579
33580 if (!args) SWIG_fail;
33581 swig_obj[0] = args;
33582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33583 if (!SWIG_IsOK(res1)) {
33584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33585 }
33586 arg1 = reinterpret_cast< wxWindow * >(argp1);
33587 {
33588 PyThreadState* __tstate = wxPyBeginAllowThreads();
33589 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33590 wxPyEndAllowThreads(__tstate);
33591 if (PyErr_Occurred()) SWIG_fail;
33592 }
33593 {
33594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33595 }
33596 return resultobj;
33597 fail:
33598 return NULL;
33599 }
33600
33601
33602 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33603 PyObject *resultobj = 0;
33604 wxWindow *arg1 = (wxWindow *) 0 ;
33605 long arg2 ;
33606 void *argp1 = 0 ;
33607 int res1 = 0 ;
33608 long val2 ;
33609 int ecode2 = 0 ;
33610 PyObject * obj0 = 0 ;
33611 PyObject * obj1 = 0 ;
33612 char * kwnames[] = {
33613 (char *) "self",(char *) "style", NULL
33614 };
33615
33616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33618 if (!SWIG_IsOK(res1)) {
33619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33620 }
33621 arg1 = reinterpret_cast< wxWindow * >(argp1);
33622 ecode2 = SWIG_AsVal_long(obj1, &val2);
33623 if (!SWIG_IsOK(ecode2)) {
33624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33625 }
33626 arg2 = static_cast< long >(val2);
33627 {
33628 PyThreadState* __tstate = wxPyBeginAllowThreads();
33629 (arg1)->SetWindowStyleFlag(arg2);
33630 wxPyEndAllowThreads(__tstate);
33631 if (PyErr_Occurred()) SWIG_fail;
33632 }
33633 resultobj = SWIG_Py_Void();
33634 return resultobj;
33635 fail:
33636 return NULL;
33637 }
33638
33639
33640 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33641 PyObject *resultobj = 0;
33642 wxWindow *arg1 = (wxWindow *) 0 ;
33643 long result;
33644 void *argp1 = 0 ;
33645 int res1 = 0 ;
33646 PyObject *swig_obj[1] ;
33647
33648 if (!args) SWIG_fail;
33649 swig_obj[0] = args;
33650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33651 if (!SWIG_IsOK(res1)) {
33652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33653 }
33654 arg1 = reinterpret_cast< wxWindow * >(argp1);
33655 {
33656 PyThreadState* __tstate = wxPyBeginAllowThreads();
33657 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33658 wxPyEndAllowThreads(__tstate);
33659 if (PyErr_Occurred()) SWIG_fail;
33660 }
33661 resultobj = SWIG_From_long(static_cast< long >(result));
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33669 PyObject *resultobj = 0;
33670 wxWindow *arg1 = (wxWindow *) 0 ;
33671 int arg2 ;
33672 bool result;
33673 void *argp1 = 0 ;
33674 int res1 = 0 ;
33675 int val2 ;
33676 int ecode2 = 0 ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 char * kwnames[] = {
33680 (char *) "self",(char *) "flag", NULL
33681 };
33682
33683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33685 if (!SWIG_IsOK(res1)) {
33686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33687 }
33688 arg1 = reinterpret_cast< wxWindow * >(argp1);
33689 ecode2 = SWIG_AsVal_int(obj1, &val2);
33690 if (!SWIG_IsOK(ecode2)) {
33691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33692 }
33693 arg2 = static_cast< int >(val2);
33694 {
33695 PyThreadState* __tstate = wxPyBeginAllowThreads();
33696 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33697 wxPyEndAllowThreads(__tstate);
33698 if (PyErr_Occurred()) SWIG_fail;
33699 }
33700 {
33701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33702 }
33703 return resultobj;
33704 fail:
33705 return NULL;
33706 }
33707
33708
33709 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33710 PyObject *resultobj = 0;
33711 wxWindow *arg1 = (wxWindow *) 0 ;
33712 bool result;
33713 void *argp1 = 0 ;
33714 int res1 = 0 ;
33715 PyObject *swig_obj[1] ;
33716
33717 if (!args) SWIG_fail;
33718 swig_obj[0] = args;
33719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33720 if (!SWIG_IsOK(res1)) {
33721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33722 }
33723 arg1 = reinterpret_cast< wxWindow * >(argp1);
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (bool)((wxWindow const *)arg1)->IsRetained();
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 {
33731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33732 }
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj = 0;
33741 wxWindow *arg1 = (wxWindow *) 0 ;
33742 long arg2 ;
33743 void *argp1 = 0 ;
33744 int res1 = 0 ;
33745 long val2 ;
33746 int ecode2 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 PyObject * obj1 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "exStyle", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_long(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33762 }
33763 arg2 = static_cast< long >(val2);
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 (arg1)->SetExtraStyle(arg2);
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 resultobj = SWIG_Py_Void();
33771 return resultobj;
33772 fail:
33773 return NULL;
33774 }
33775
33776
33777 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33778 PyObject *resultobj = 0;
33779 wxWindow *arg1 = (wxWindow *) 0 ;
33780 long result;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 PyObject *swig_obj[1] ;
33784
33785 if (!args) SWIG_fail;
33786 swig_obj[0] = args;
33787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33788 if (!SWIG_IsOK(res1)) {
33789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33790 }
33791 arg1 = reinterpret_cast< wxWindow * >(argp1);
33792 {
33793 PyThreadState* __tstate = wxPyBeginAllowThreads();
33794 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33795 wxPyEndAllowThreads(__tstate);
33796 if (PyErr_Occurred()) SWIG_fail;
33797 }
33798 resultobj = SWIG_From_long(static_cast< long >(result));
33799 return resultobj;
33800 fail:
33801 return NULL;
33802 }
33803
33804
33805 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33806 PyObject *resultobj = 0;
33807 wxWindow *arg1 = (wxWindow *) 0 ;
33808 bool arg2 = (bool) true ;
33809 void *argp1 = 0 ;
33810 int res1 = 0 ;
33811 bool val2 ;
33812 int ecode2 = 0 ;
33813 PyObject * obj0 = 0 ;
33814 PyObject * obj1 = 0 ;
33815 char * kwnames[] = {
33816 (char *) "self",(char *) "modal", NULL
33817 };
33818
33819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33821 if (!SWIG_IsOK(res1)) {
33822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33823 }
33824 arg1 = reinterpret_cast< wxWindow * >(argp1);
33825 if (obj1) {
33826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33827 if (!SWIG_IsOK(ecode2)) {
33828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33829 }
33830 arg2 = static_cast< bool >(val2);
33831 }
33832 {
33833 PyThreadState* __tstate = wxPyBeginAllowThreads();
33834 (arg1)->MakeModal(arg2);
33835 wxPyEndAllowThreads(__tstate);
33836 if (PyErr_Occurred()) SWIG_fail;
33837 }
33838 resultobj = SWIG_Py_Void();
33839 return resultobj;
33840 fail:
33841 return NULL;
33842 }
33843
33844
33845 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33846 PyObject *resultobj = 0;
33847 wxWindow *arg1 = (wxWindow *) 0 ;
33848 bool arg2 ;
33849 void *argp1 = 0 ;
33850 int res1 = 0 ;
33851 bool val2 ;
33852 int ecode2 = 0 ;
33853 PyObject * obj0 = 0 ;
33854 PyObject * obj1 = 0 ;
33855 char * kwnames[] = {
33856 (char *) "self",(char *) "enableTheme", NULL
33857 };
33858
33859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33861 if (!SWIG_IsOK(res1)) {
33862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33863 }
33864 arg1 = reinterpret_cast< wxWindow * >(argp1);
33865 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33866 if (!SWIG_IsOK(ecode2)) {
33867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33868 }
33869 arg2 = static_cast< bool >(val2);
33870 {
33871 PyThreadState* __tstate = wxPyBeginAllowThreads();
33872 (arg1)->SetThemeEnabled(arg2);
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 resultobj = SWIG_Py_Void();
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33884 PyObject *resultobj = 0;
33885 wxWindow *arg1 = (wxWindow *) 0 ;
33886 bool result;
33887 void *argp1 = 0 ;
33888 int res1 = 0 ;
33889 PyObject *swig_obj[1] ;
33890
33891 if (!args) SWIG_fail;
33892 swig_obj[0] = args;
33893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33894 if (!SWIG_IsOK(res1)) {
33895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33896 }
33897 arg1 = reinterpret_cast< wxWindow * >(argp1);
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 {
33905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33906 }
33907 return resultobj;
33908 fail:
33909 return NULL;
33910 }
33911
33912
33913 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33914 PyObject *resultobj = 0;
33915 wxWindow *arg1 = (wxWindow *) 0 ;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 PyObject *swig_obj[1] ;
33919
33920 if (!args) SWIG_fail;
33921 swig_obj[0] = args;
33922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33923 if (!SWIG_IsOK(res1)) {
33924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33925 }
33926 arg1 = reinterpret_cast< wxWindow * >(argp1);
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->SetFocus();
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33941 PyObject *resultobj = 0;
33942 wxWindow *arg1 = (wxWindow *) 0 ;
33943 void *argp1 = 0 ;
33944 int res1 = 0 ;
33945 PyObject *swig_obj[1] ;
33946
33947 if (!args) SWIG_fail;
33948 swig_obj[0] = args;
33949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33950 if (!SWIG_IsOK(res1)) {
33951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33952 }
33953 arg1 = reinterpret_cast< wxWindow * >(argp1);
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 (arg1)->SetFocusFromKbd();
33957 wxPyEndAllowThreads(__tstate);
33958 if (PyErr_Occurred()) SWIG_fail;
33959 }
33960 resultobj = SWIG_Py_Void();
33961 return resultobj;
33962 fail:
33963 return NULL;
33964 }
33965
33966
33967 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33968 PyObject *resultobj = 0;
33969 wxWindow *result = 0 ;
33970
33971 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33972 {
33973 if (!wxPyCheckForApp()) SWIG_fail;
33974 PyThreadState* __tstate = wxPyBeginAllowThreads();
33975 result = (wxWindow *)wxWindow::FindFocus();
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 {
33980 resultobj = wxPyMake_wxObject(result, 0);
33981 }
33982 return resultobj;
33983 fail:
33984 return NULL;
33985 }
33986
33987
33988 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33989 PyObject *resultobj = 0;
33990 wxWindow *arg1 = (wxWindow *) 0 ;
33991 bool result;
33992 void *argp1 = 0 ;
33993 int res1 = 0 ;
33994 PyObject *swig_obj[1] ;
33995
33996 if (!args) SWIG_fail;
33997 swig_obj[0] = args;
33998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33999 if (!SWIG_IsOK(res1)) {
34000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34001 }
34002 arg1 = reinterpret_cast< wxWindow * >(argp1);
34003 {
34004 PyThreadState* __tstate = wxPyBeginAllowThreads();
34005 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 {
34010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34011 }
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34019 PyObject *resultobj = 0;
34020 wxWindow *arg1 = (wxWindow *) 0 ;
34021 bool result;
34022 void *argp1 = 0 ;
34023 int res1 = 0 ;
34024 PyObject *swig_obj[1] ;
34025
34026 if (!args) SWIG_fail;
34027 swig_obj[0] = args;
34028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34031 }
34032 arg1 = reinterpret_cast< wxWindow * >(argp1);
34033 {
34034 PyThreadState* __tstate = wxPyBeginAllowThreads();
34035 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34036 wxPyEndAllowThreads(__tstate);
34037 if (PyErr_Occurred()) SWIG_fail;
34038 }
34039 {
34040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34041 }
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxWindow *arg1 = (wxWindow *) 0 ;
34051 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34052 bool result;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 int val2 ;
34056 int ecode2 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 char * kwnames[] = {
34060 (char *) "self",(char *) "flags", NULL
34061 };
34062
34063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34067 }
34068 arg1 = reinterpret_cast< wxWindow * >(argp1);
34069 if (obj1) {
34070 ecode2 = SWIG_AsVal_int(obj1, &val2);
34071 if (!SWIG_IsOK(ecode2)) {
34072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34073 }
34074 arg2 = static_cast< int >(val2);
34075 }
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 result = (bool)(arg1)->Navigate(arg2);
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 {
34083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34084 }
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxWindow *arg2 = (wxWindow *) 0 ;
34095 void *argp1 = 0 ;
34096 int res1 = 0 ;
34097 void *argp2 = 0 ;
34098 int res2 = 0 ;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char * kwnames[] = {
34102 (char *) "self",(char *) "win", NULL
34103 };
34104
34105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34107 if (!SWIG_IsOK(res1)) {
34108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34109 }
34110 arg1 = reinterpret_cast< wxWindow * >(argp1);
34111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34112 if (!SWIG_IsOK(res2)) {
34113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34114 }
34115 arg2 = reinterpret_cast< wxWindow * >(argp2);
34116 {
34117 PyThreadState* __tstate = wxPyBeginAllowThreads();
34118 (arg1)->MoveAfterInTabOrder(arg2);
34119 wxPyEndAllowThreads(__tstate);
34120 if (PyErr_Occurred()) SWIG_fail;
34121 }
34122 resultobj = SWIG_Py_Void();
34123 return resultobj;
34124 fail:
34125 return NULL;
34126 }
34127
34128
34129 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34130 PyObject *resultobj = 0;
34131 wxWindow *arg1 = (wxWindow *) 0 ;
34132 wxWindow *arg2 = (wxWindow *) 0 ;
34133 void *argp1 = 0 ;
34134 int res1 = 0 ;
34135 void *argp2 = 0 ;
34136 int res2 = 0 ;
34137 PyObject * obj0 = 0 ;
34138 PyObject * obj1 = 0 ;
34139 char * kwnames[] = {
34140 (char *) "self",(char *) "win", NULL
34141 };
34142
34143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34145 if (!SWIG_IsOK(res1)) {
34146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34147 }
34148 arg1 = reinterpret_cast< wxWindow * >(argp1);
34149 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34150 if (!SWIG_IsOK(res2)) {
34151 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34152 }
34153 arg2 = reinterpret_cast< wxWindow * >(argp2);
34154 {
34155 PyThreadState* __tstate = wxPyBeginAllowThreads();
34156 (arg1)->MoveBeforeInTabOrder(arg2);
34157 wxPyEndAllowThreads(__tstate);
34158 if (PyErr_Occurred()) SWIG_fail;
34159 }
34160 resultobj = SWIG_Py_Void();
34161 return resultobj;
34162 fail:
34163 return NULL;
34164 }
34165
34166
34167 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34168 PyObject *resultobj = 0;
34169 wxWindow *arg1 = (wxWindow *) 0 ;
34170 PyObject *result = 0 ;
34171 void *argp1 = 0 ;
34172 int res1 = 0 ;
34173 PyObject *swig_obj[1] ;
34174
34175 if (!args) SWIG_fail;
34176 swig_obj[0] = args;
34177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34178 if (!SWIG_IsOK(res1)) {
34179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = (PyObject *)wxWindow_GetChildren(arg1);
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = result;
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 wxWindow *result = 0 ;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 PyObject *swig_obj[1] ;
34202
34203 if (!args) SWIG_fail;
34204 swig_obj[0] = args;
34205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34206 if (!SWIG_IsOK(res1)) {
34207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34208 }
34209 arg1 = reinterpret_cast< wxWindow * >(argp1);
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34213 wxPyEndAllowThreads(__tstate);
34214 if (PyErr_Occurred()) SWIG_fail;
34215 }
34216 {
34217 resultobj = wxPyMake_wxObject(result, 0);
34218 }
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxWindow *arg1 = (wxWindow *) 0 ;
34228 wxWindow *result = 0 ;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
34233 if (!args) SWIG_fail;
34234 swig_obj[0] = args;
34235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34236 if (!SWIG_IsOK(res1)) {
34237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 {
34247 resultobj = wxPyMake_wxObject(result, 0);
34248 }
34249 return resultobj;
34250 fail:
34251 return NULL;
34252 }
34253
34254
34255 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34256 PyObject *resultobj = 0;
34257 wxWindow *arg1 = (wxWindow *) 0 ;
34258 bool result;
34259 void *argp1 = 0 ;
34260 int res1 = 0 ;
34261 PyObject *swig_obj[1] ;
34262
34263 if (!args) SWIG_fail;
34264 swig_obj[0] = args;
34265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34266 if (!SWIG_IsOK(res1)) {
34267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34268 }
34269 arg1 = reinterpret_cast< wxWindow * >(argp1);
34270 {
34271 PyThreadState* __tstate = wxPyBeginAllowThreads();
34272 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34273 wxPyEndAllowThreads(__tstate);
34274 if (PyErr_Occurred()) SWIG_fail;
34275 }
34276 {
34277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34278 }
34279 return resultobj;
34280 fail:
34281 return NULL;
34282 }
34283
34284
34285 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34286 PyObject *resultobj = 0;
34287 wxWindow *arg1 = (wxWindow *) 0 ;
34288 wxWindow *arg2 = (wxWindow *) 0 ;
34289 bool result;
34290 void *argp1 = 0 ;
34291 int res1 = 0 ;
34292 void *argp2 = 0 ;
34293 int res2 = 0 ;
34294 PyObject * obj0 = 0 ;
34295 PyObject * obj1 = 0 ;
34296 char * kwnames[] = {
34297 (char *) "self",(char *) "newParent", NULL
34298 };
34299
34300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34302 if (!SWIG_IsOK(res1)) {
34303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34304 }
34305 arg1 = reinterpret_cast< wxWindow * >(argp1);
34306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34307 if (!SWIG_IsOK(res2)) {
34308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34309 }
34310 arg2 = reinterpret_cast< wxWindow * >(argp2);
34311 {
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 result = (bool)(arg1)->Reparent(arg2);
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 {
34318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34319 }
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34327 PyObject *resultobj = 0;
34328 wxWindow *arg1 = (wxWindow *) 0 ;
34329 wxWindow *arg2 = (wxWindow *) 0 ;
34330 void *argp1 = 0 ;
34331 int res1 = 0 ;
34332 void *argp2 = 0 ;
34333 int res2 = 0 ;
34334 PyObject * obj0 = 0 ;
34335 PyObject * obj1 = 0 ;
34336 char * kwnames[] = {
34337 (char *) "self",(char *) "child", NULL
34338 };
34339
34340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",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_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34347 if (!SWIG_IsOK(res2)) {
34348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34349 }
34350 arg2 = reinterpret_cast< wxWindow * >(argp2);
34351 {
34352 PyThreadState* __tstate = wxPyBeginAllowThreads();
34353 (arg1)->AddChild(arg2);
34354 wxPyEndAllowThreads(__tstate);
34355 if (PyErr_Occurred()) SWIG_fail;
34356 }
34357 resultobj = SWIG_Py_Void();
34358 return resultobj;
34359 fail:
34360 return NULL;
34361 }
34362
34363
34364 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34365 PyObject *resultobj = 0;
34366 wxWindow *arg1 = (wxWindow *) 0 ;
34367 wxWindow *arg2 = (wxWindow *) 0 ;
34368 void *argp1 = 0 ;
34369 int res1 = 0 ;
34370 void *argp2 = 0 ;
34371 int res2 = 0 ;
34372 PyObject * obj0 = 0 ;
34373 PyObject * obj1 = 0 ;
34374 char * kwnames[] = {
34375 (char *) "self",(char *) "child", NULL
34376 };
34377
34378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34380 if (!SWIG_IsOK(res1)) {
34381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34382 }
34383 arg1 = reinterpret_cast< wxWindow * >(argp1);
34384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34385 if (!SWIG_IsOK(res2)) {
34386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34387 }
34388 arg2 = reinterpret_cast< wxWindow * >(argp2);
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 (arg1)->RemoveChild(arg2);
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 resultobj = SWIG_Py_Void();
34396 return resultobj;
34397 fail:
34398 return NULL;
34399 }
34400
34401
34402 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj = 0;
34404 wxWindow *arg1 = (wxWindow *) 0 ;
34405 bool arg2 ;
34406 void *argp1 = 0 ;
34407 int res1 = 0 ;
34408 bool val2 ;
34409 int ecode2 = 0 ;
34410 PyObject * obj0 = 0 ;
34411 PyObject * obj1 = 0 ;
34412 char * kwnames[] = {
34413 (char *) "self",(char *) "on", NULL
34414 };
34415
34416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34418 if (!SWIG_IsOK(res1)) {
34419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34420 }
34421 arg1 = reinterpret_cast< wxWindow * >(argp1);
34422 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34423 if (!SWIG_IsOK(ecode2)) {
34424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34425 }
34426 arg2 = static_cast< bool >(val2);
34427 {
34428 PyThreadState* __tstate = wxPyBeginAllowThreads();
34429 wxWindow_SetDoubleBuffered(arg1,arg2);
34430 wxPyEndAllowThreads(__tstate);
34431 if (PyErr_Occurred()) SWIG_fail;
34432 }
34433 resultobj = SWIG_Py_Void();
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34441 PyObject *resultobj = 0;
34442 wxWindow *arg1 = (wxWindow *) 0 ;
34443 long arg2 ;
34444 wxWindow *result = 0 ;
34445 void *argp1 = 0 ;
34446 int res1 = 0 ;
34447 long val2 ;
34448 int ecode2 = 0 ;
34449 PyObject * obj0 = 0 ;
34450 PyObject * obj1 = 0 ;
34451 char * kwnames[] = {
34452 (char *) "self",(char *) "winid", NULL
34453 };
34454
34455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34457 if (!SWIG_IsOK(res1)) {
34458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34459 }
34460 arg1 = reinterpret_cast< wxWindow * >(argp1);
34461 ecode2 = SWIG_AsVal_long(obj1, &val2);
34462 if (!SWIG_IsOK(ecode2)) {
34463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34464 }
34465 arg2 = static_cast< long >(val2);
34466 {
34467 PyThreadState* __tstate = wxPyBeginAllowThreads();
34468 result = (wxWindow *)(arg1)->FindWindow(arg2);
34469 wxPyEndAllowThreads(__tstate);
34470 if (PyErr_Occurred()) SWIG_fail;
34471 }
34472 {
34473 resultobj = wxPyMake_wxObject(result, 0);
34474 }
34475 return resultobj;
34476 fail:
34477 return NULL;
34478 }
34479
34480
34481 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34482 PyObject *resultobj = 0;
34483 wxWindow *arg1 = (wxWindow *) 0 ;
34484 wxString *arg2 = 0 ;
34485 wxWindow *result = 0 ;
34486 void *argp1 = 0 ;
34487 int res1 = 0 ;
34488 bool temp2 = false ;
34489 PyObject * obj0 = 0 ;
34490 PyObject * obj1 = 0 ;
34491 char * kwnames[] = {
34492 (char *) "self",(char *) "name", NULL
34493 };
34494
34495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34497 if (!SWIG_IsOK(res1)) {
34498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34499 }
34500 arg1 = reinterpret_cast< wxWindow * >(argp1);
34501 {
34502 arg2 = wxString_in_helper(obj1);
34503 if (arg2 == NULL) SWIG_fail;
34504 temp2 = true;
34505 }
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34509 wxPyEndAllowThreads(__tstate);
34510 if (PyErr_Occurred()) SWIG_fail;
34511 }
34512 {
34513 resultobj = wxPyMake_wxObject(result, 0);
34514 }
34515 {
34516 if (temp2)
34517 delete arg2;
34518 }
34519 return resultobj;
34520 fail:
34521 {
34522 if (temp2)
34523 delete arg2;
34524 }
34525 return NULL;
34526 }
34527
34528
34529 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34530 PyObject *resultobj = 0;
34531 wxWindow *arg1 = (wxWindow *) 0 ;
34532 wxEvtHandler *result = 0 ;
34533 void *argp1 = 0 ;
34534 int res1 = 0 ;
34535 PyObject *swig_obj[1] ;
34536
34537 if (!args) SWIG_fail;
34538 swig_obj[0] = args;
34539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34540 if (!SWIG_IsOK(res1)) {
34541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34542 }
34543 arg1 = reinterpret_cast< wxWindow * >(argp1);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 {
34551 resultobj = wxPyMake_wxObject(result, 0);
34552 }
34553 return resultobj;
34554 fail:
34555 return NULL;
34556 }
34557
34558
34559 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34560 PyObject *resultobj = 0;
34561 wxWindow *arg1 = (wxWindow *) 0 ;
34562 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 void *argp2 = 0 ;
34566 int res2 = 0 ;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char * kwnames[] = {
34570 (char *) "self",(char *) "handler", NULL
34571 };
34572
34573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34580 if (!SWIG_IsOK(res2)) {
34581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34582 }
34583 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34584 {
34585 PyThreadState* __tstate = wxPyBeginAllowThreads();
34586 (arg1)->SetEventHandler(arg2);
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 resultobj = SWIG_Py_Void();
34591 return resultobj;
34592 fail:
34593 return NULL;
34594 }
34595
34596
34597 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj = 0;
34599 wxWindow *arg1 = (wxWindow *) 0 ;
34600 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 void *argp2 = 0 ;
34604 int res2 = 0 ;
34605 PyObject * obj0 = 0 ;
34606 PyObject * obj1 = 0 ;
34607 char * kwnames[] = {
34608 (char *) "self",(char *) "handler", NULL
34609 };
34610
34611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34613 if (!SWIG_IsOK(res1)) {
34614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34615 }
34616 arg1 = reinterpret_cast< wxWindow * >(argp1);
34617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34618 if (!SWIG_IsOK(res2)) {
34619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34620 }
34621 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 (arg1)->PushEventHandler(arg2);
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 resultobj = SWIG_Py_Void();
34629 return resultobj;
34630 fail:
34631 return NULL;
34632 }
34633
34634
34635 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34636 PyObject *resultobj = 0;
34637 wxWindow *arg1 = (wxWindow *) 0 ;
34638 bool arg2 = (bool) false ;
34639 wxEvtHandler *result = 0 ;
34640 void *argp1 = 0 ;
34641 int res1 = 0 ;
34642 bool val2 ;
34643 int ecode2 = 0 ;
34644 PyObject * obj0 = 0 ;
34645 PyObject * obj1 = 0 ;
34646 char * kwnames[] = {
34647 (char *) "self",(char *) "deleteHandler", NULL
34648 };
34649
34650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34652 if (!SWIG_IsOK(res1)) {
34653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34654 }
34655 arg1 = reinterpret_cast< wxWindow * >(argp1);
34656 if (obj1) {
34657 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34658 if (!SWIG_IsOK(ecode2)) {
34659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34660 }
34661 arg2 = static_cast< bool >(val2);
34662 }
34663 {
34664 PyThreadState* __tstate = wxPyBeginAllowThreads();
34665 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34666 wxPyEndAllowThreads(__tstate);
34667 if (PyErr_Occurred()) SWIG_fail;
34668 }
34669 {
34670 resultobj = wxPyMake_wxObject(result, 0);
34671 }
34672 return resultobj;
34673 fail:
34674 return NULL;
34675 }
34676
34677
34678 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34679 PyObject *resultobj = 0;
34680 wxWindow *arg1 = (wxWindow *) 0 ;
34681 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34682 bool result;
34683 void *argp1 = 0 ;
34684 int res1 = 0 ;
34685 void *argp2 = 0 ;
34686 int res2 = 0 ;
34687 PyObject * obj0 = 0 ;
34688 PyObject * obj1 = 0 ;
34689 char * kwnames[] = {
34690 (char *) "self",(char *) "handler", NULL
34691 };
34692
34693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34695 if (!SWIG_IsOK(res1)) {
34696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34697 }
34698 arg1 = reinterpret_cast< wxWindow * >(argp1);
34699 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34700 if (!SWIG_IsOK(res2)) {
34701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34702 }
34703 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34704 {
34705 PyThreadState* __tstate = wxPyBeginAllowThreads();
34706 result = (bool)(arg1)->RemoveEventHandler(arg2);
34707 wxPyEndAllowThreads(__tstate);
34708 if (PyErr_Occurred()) SWIG_fail;
34709 }
34710 {
34711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34712 }
34713 return resultobj;
34714 fail:
34715 return NULL;
34716 }
34717
34718
34719 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34720 PyObject *resultobj = 0;
34721 wxWindow *arg1 = (wxWindow *) 0 ;
34722 wxValidator *arg2 = 0 ;
34723 void *argp1 = 0 ;
34724 int res1 = 0 ;
34725 void *argp2 = 0 ;
34726 int res2 = 0 ;
34727 PyObject * obj0 = 0 ;
34728 PyObject * obj1 = 0 ;
34729 char * kwnames[] = {
34730 (char *) "self",(char *) "validator", NULL
34731 };
34732
34733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34737 }
34738 arg1 = reinterpret_cast< wxWindow * >(argp1);
34739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34740 if (!SWIG_IsOK(res2)) {
34741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34742 }
34743 if (!argp2) {
34744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34745 }
34746 arg2 = reinterpret_cast< wxValidator * >(argp2);
34747 {
34748 PyThreadState* __tstate = wxPyBeginAllowThreads();
34749 (arg1)->SetValidator((wxValidator const &)*arg2);
34750 wxPyEndAllowThreads(__tstate);
34751 if (PyErr_Occurred()) SWIG_fail;
34752 }
34753 resultobj = SWIG_Py_Void();
34754 return resultobj;
34755 fail:
34756 return NULL;
34757 }
34758
34759
34760 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34761 PyObject *resultobj = 0;
34762 wxWindow *arg1 = (wxWindow *) 0 ;
34763 wxValidator *result = 0 ;
34764 void *argp1 = 0 ;
34765 int res1 = 0 ;
34766 PyObject *swig_obj[1] ;
34767
34768 if (!args) SWIG_fail;
34769 swig_obj[0] = args;
34770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34771 if (!SWIG_IsOK(res1)) {
34772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34773 }
34774 arg1 = reinterpret_cast< wxWindow * >(argp1);
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = (wxValidator *)(arg1)->GetValidator();
34778 wxPyEndAllowThreads(__tstate);
34779 if (PyErr_Occurred()) SWIG_fail;
34780 }
34781 {
34782 resultobj = wxPyMake_wxObject(result, (bool)0);
34783 }
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34791 PyObject *resultobj = 0;
34792 wxWindow *arg1 = (wxWindow *) 0 ;
34793 bool result;
34794 void *argp1 = 0 ;
34795 int res1 = 0 ;
34796 PyObject *swig_obj[1] ;
34797
34798 if (!args) SWIG_fail;
34799 swig_obj[0] = args;
34800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34803 }
34804 arg1 = reinterpret_cast< wxWindow * >(argp1);
34805 {
34806 PyThreadState* __tstate = wxPyBeginAllowThreads();
34807 result = (bool)(arg1)->Validate();
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 {
34812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34813 }
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34821 PyObject *resultobj = 0;
34822 wxWindow *arg1 = (wxWindow *) 0 ;
34823 bool result;
34824 void *argp1 = 0 ;
34825 int res1 = 0 ;
34826 PyObject *swig_obj[1] ;
34827
34828 if (!args) SWIG_fail;
34829 swig_obj[0] = args;
34830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34831 if (!SWIG_IsOK(res1)) {
34832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34833 }
34834 arg1 = reinterpret_cast< wxWindow * >(argp1);
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 result = (bool)(arg1)->TransferDataToWindow();
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 {
34842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34843 }
34844 return resultobj;
34845 fail:
34846 return NULL;
34847 }
34848
34849
34850 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34851 PyObject *resultobj = 0;
34852 wxWindow *arg1 = (wxWindow *) 0 ;
34853 bool result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 PyObject *swig_obj[1] ;
34857
34858 if (!args) SWIG_fail;
34859 swig_obj[0] = args;
34860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34861 if (!SWIG_IsOK(res1)) {
34862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34863 }
34864 arg1 = reinterpret_cast< wxWindow * >(argp1);
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 result = (bool)(arg1)->TransferDataFromWindow();
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 {
34872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34873 }
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34881 PyObject *resultobj = 0;
34882 wxWindow *arg1 = (wxWindow *) 0 ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 PyObject *swig_obj[1] ;
34886
34887 if (!args) SWIG_fail;
34888 swig_obj[0] = args;
34889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34890 if (!SWIG_IsOK(res1)) {
34891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34892 }
34893 arg1 = reinterpret_cast< wxWindow * >(argp1);
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 (arg1)->InitDialog();
34897 wxPyEndAllowThreads(__tstate);
34898 if (PyErr_Occurred()) SWIG_fail;
34899 }
34900 resultobj = SWIG_Py_Void();
34901 return resultobj;
34902 fail:
34903 return NULL;
34904 }
34905
34906
34907 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34908 PyObject *resultobj = 0;
34909 wxWindow *arg1 = (wxWindow *) 0 ;
34910 wxAcceleratorTable *arg2 = 0 ;
34911 void *argp1 = 0 ;
34912 int res1 = 0 ;
34913 void *argp2 = 0 ;
34914 int res2 = 0 ;
34915 PyObject * obj0 = 0 ;
34916 PyObject * obj1 = 0 ;
34917 char * kwnames[] = {
34918 (char *) "self",(char *) "accel", NULL
34919 };
34920
34921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34923 if (!SWIG_IsOK(res1)) {
34924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34925 }
34926 arg1 = reinterpret_cast< wxWindow * >(argp1);
34927 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34928 if (!SWIG_IsOK(res2)) {
34929 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34930 }
34931 if (!argp2) {
34932 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34933 }
34934 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34935 {
34936 PyThreadState* __tstate = wxPyBeginAllowThreads();
34937 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34938 wxPyEndAllowThreads(__tstate);
34939 if (PyErr_Occurred()) SWIG_fail;
34940 }
34941 resultobj = SWIG_Py_Void();
34942 return resultobj;
34943 fail:
34944 return NULL;
34945 }
34946
34947
34948 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34949 PyObject *resultobj = 0;
34950 wxWindow *arg1 = (wxWindow *) 0 ;
34951 wxAcceleratorTable *result = 0 ;
34952 void *argp1 = 0 ;
34953 int res1 = 0 ;
34954 PyObject *swig_obj[1] ;
34955
34956 if (!args) SWIG_fail;
34957 swig_obj[0] = args;
34958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34959 if (!SWIG_IsOK(res1)) {
34960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34961 }
34962 arg1 = reinterpret_cast< wxWindow * >(argp1);
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj = 0;
34978 wxWindow *arg1 = (wxWindow *) 0 ;
34979 int arg2 ;
34980 int arg3 ;
34981 int arg4 ;
34982 bool result;
34983 void *argp1 = 0 ;
34984 int res1 = 0 ;
34985 int val2 ;
34986 int ecode2 = 0 ;
34987 int val3 ;
34988 int ecode3 = 0 ;
34989 int val4 ;
34990 int ecode4 = 0 ;
34991 PyObject * obj0 = 0 ;
34992 PyObject * obj1 = 0 ;
34993 PyObject * obj2 = 0 ;
34994 PyObject * obj3 = 0 ;
34995 char * kwnames[] = {
34996 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34997 };
34998
34999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35001 if (!SWIG_IsOK(res1)) {
35002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35003 }
35004 arg1 = reinterpret_cast< wxWindow * >(argp1);
35005 ecode2 = SWIG_AsVal_int(obj1, &val2);
35006 if (!SWIG_IsOK(ecode2)) {
35007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35008 }
35009 arg2 = static_cast< int >(val2);
35010 ecode3 = SWIG_AsVal_int(obj2, &val3);
35011 if (!SWIG_IsOK(ecode3)) {
35012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35013 }
35014 arg3 = static_cast< int >(val3);
35015 ecode4 = SWIG_AsVal_int(obj3, &val4);
35016 if (!SWIG_IsOK(ecode4)) {
35017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35018 }
35019 arg4 = static_cast< int >(val4);
35020 {
35021 PyThreadState* __tstate = wxPyBeginAllowThreads();
35022 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 {
35027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35028 }
35029 return resultobj;
35030 fail:
35031 return NULL;
35032 }
35033
35034
35035 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 int arg2 ;
35039 bool result;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 int val2 ;
35043 int ecode2 = 0 ;
35044 PyObject * obj0 = 0 ;
35045 PyObject * obj1 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "hotkeyId", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35052 if (!SWIG_IsOK(res1)) {
35053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 ecode2 = SWIG_AsVal_int(obj1, &val2);
35057 if (!SWIG_IsOK(ecode2)) {
35058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35059 }
35060 arg2 = static_cast< int >(val2);
35061 {
35062 PyThreadState* __tstate = wxPyBeginAllowThreads();
35063 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35064 wxPyEndAllowThreads(__tstate);
35065 if (PyErr_Occurred()) SWIG_fail;
35066 }
35067 {
35068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35069 }
35070 return resultobj;
35071 fail:
35072 return NULL;
35073 }
35074
35075
35076 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35077 PyObject *resultobj = 0;
35078 wxWindow *arg1 = (wxWindow *) 0 ;
35079 wxPoint *arg2 = 0 ;
35080 wxPoint result;
35081 void *argp1 = 0 ;
35082 int res1 = 0 ;
35083 wxPoint temp2 ;
35084 PyObject * obj0 = 0 ;
35085 PyObject * obj1 = 0 ;
35086 char * kwnames[] = {
35087 (char *) "self",(char *) "pt", NULL
35088 };
35089
35090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35092 if (!SWIG_IsOK(res1)) {
35093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35094 }
35095 arg1 = reinterpret_cast< wxWindow * >(argp1);
35096 {
35097 arg2 = &temp2;
35098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35099 }
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35114 PyObject *resultobj = 0;
35115 wxWindow *arg1 = (wxWindow *) 0 ;
35116 wxSize *arg2 = 0 ;
35117 wxSize result;
35118 void *argp1 = 0 ;
35119 int res1 = 0 ;
35120 wxSize temp2 ;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 char * kwnames[] = {
35124 (char *) "self",(char *) "sz", NULL
35125 };
35126
35127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35129 if (!SWIG_IsOK(res1)) {
35130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35131 }
35132 arg1 = reinterpret_cast< wxWindow * >(argp1);
35133 {
35134 arg2 = &temp2;
35135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35136 }
35137 {
35138 PyThreadState* __tstate = wxPyBeginAllowThreads();
35139 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35140 wxPyEndAllowThreads(__tstate);
35141 if (PyErr_Occurred()) SWIG_fail;
35142 }
35143 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35144 return resultobj;
35145 fail:
35146 return NULL;
35147 }
35148
35149
35150 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35151 PyObject *resultobj = 0;
35152 wxWindow *arg1 = (wxWindow *) 0 ;
35153 wxPoint *arg2 = 0 ;
35154 wxPoint result;
35155 void *argp1 = 0 ;
35156 int res1 = 0 ;
35157 wxPoint temp2 ;
35158 PyObject * obj0 = 0 ;
35159 PyObject * obj1 = 0 ;
35160 char * kwnames[] = {
35161 (char *) "self",(char *) "pt", NULL
35162 };
35163
35164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35166 if (!SWIG_IsOK(res1)) {
35167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35168 }
35169 arg1 = reinterpret_cast< wxWindow * >(argp1);
35170 {
35171 arg2 = &temp2;
35172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35173 }
35174 {
35175 PyThreadState* __tstate = wxPyBeginAllowThreads();
35176 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35177 wxPyEndAllowThreads(__tstate);
35178 if (PyErr_Occurred()) SWIG_fail;
35179 }
35180 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35181 return resultobj;
35182 fail:
35183 return NULL;
35184 }
35185
35186
35187 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35188 PyObject *resultobj = 0;
35189 wxWindow *arg1 = (wxWindow *) 0 ;
35190 wxSize *arg2 = 0 ;
35191 wxSize result;
35192 void *argp1 = 0 ;
35193 int res1 = 0 ;
35194 wxSize temp2 ;
35195 PyObject * obj0 = 0 ;
35196 PyObject * obj1 = 0 ;
35197 char * kwnames[] = {
35198 (char *) "self",(char *) "sz", NULL
35199 };
35200
35201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) 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_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 arg2 = &temp2;
35209 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35210 }
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35214 wxPyEndAllowThreads(__tstate);
35215 if (PyErr_Occurred()) SWIG_fail;
35216 }
35217 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35218 return resultobj;
35219 fail:
35220 return NULL;
35221 }
35222
35223
35224 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35225 PyObject *resultobj = 0;
35226 wxWindow *arg1 = (wxWindow *) 0 ;
35227 wxPoint *arg2 = 0 ;
35228 wxPoint result;
35229 void *argp1 = 0 ;
35230 int res1 = 0 ;
35231 wxPoint temp2 ;
35232 PyObject * obj0 = 0 ;
35233 PyObject * obj1 = 0 ;
35234 char * kwnames[] = {
35235 (char *) "self",(char *) "pt", NULL
35236 };
35237
35238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35240 if (!SWIG_IsOK(res1)) {
35241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35242 }
35243 arg1 = reinterpret_cast< wxWindow * >(argp1);
35244 {
35245 arg2 = &temp2;
35246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35247 }
35248 {
35249 PyThreadState* __tstate = wxPyBeginAllowThreads();
35250 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35251 wxPyEndAllowThreads(__tstate);
35252 if (PyErr_Occurred()) SWIG_fail;
35253 }
35254 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35255 return resultobj;
35256 fail:
35257 return NULL;
35258 }
35259
35260
35261 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35262 PyObject *resultobj = 0;
35263 wxWindow *arg1 = (wxWindow *) 0 ;
35264 wxSize *arg2 = 0 ;
35265 wxSize result;
35266 void *argp1 = 0 ;
35267 int res1 = 0 ;
35268 wxSize temp2 ;
35269 PyObject * obj0 = 0 ;
35270 PyObject * obj1 = 0 ;
35271 char * kwnames[] = {
35272 (char *) "self",(char *) "sz", NULL
35273 };
35274
35275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35277 if (!SWIG_IsOK(res1)) {
35278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35279 }
35280 arg1 = reinterpret_cast< wxWindow * >(argp1);
35281 {
35282 arg2 = &temp2;
35283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35284 }
35285 {
35286 PyThreadState* __tstate = wxPyBeginAllowThreads();
35287 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35288 wxPyEndAllowThreads(__tstate);
35289 if (PyErr_Occurred()) SWIG_fail;
35290 }
35291 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 int arg2 ;
35302 int arg3 ;
35303 void *argp1 = 0 ;
35304 int res1 = 0 ;
35305 int val2 ;
35306 int ecode2 = 0 ;
35307 int val3 ;
35308 int ecode3 = 0 ;
35309 PyObject * obj0 = 0 ;
35310 PyObject * obj1 = 0 ;
35311 PyObject * obj2 = 0 ;
35312 char * kwnames[] = {
35313 (char *) "self",(char *) "x",(char *) "y", NULL
35314 };
35315
35316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35318 if (!SWIG_IsOK(res1)) {
35319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35320 }
35321 arg1 = reinterpret_cast< wxWindow * >(argp1);
35322 ecode2 = SWIG_AsVal_int(obj1, &val2);
35323 if (!SWIG_IsOK(ecode2)) {
35324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35325 }
35326 arg2 = static_cast< int >(val2);
35327 ecode3 = SWIG_AsVal_int(obj2, &val3);
35328 if (!SWIG_IsOK(ecode3)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35330 }
35331 arg3 = static_cast< int >(val3);
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 (arg1)->WarpPointer(arg2,arg3);
35335 wxPyEndAllowThreads(__tstate);
35336 if (PyErr_Occurred()) SWIG_fail;
35337 }
35338 resultobj = SWIG_Py_Void();
35339 return resultobj;
35340 fail:
35341 return NULL;
35342 }
35343
35344
35345 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35346 PyObject *resultobj = 0;
35347 wxWindow *arg1 = (wxWindow *) 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 PyObject *swig_obj[1] ;
35351
35352 if (!args) SWIG_fail;
35353 swig_obj[0] = args;
35354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35355 if (!SWIG_IsOK(res1)) {
35356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35357 }
35358 arg1 = reinterpret_cast< wxWindow * >(argp1);
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->CaptureMouse();
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 resultobj = SWIG_Py_Void();
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35373 PyObject *resultobj = 0;
35374 wxWindow *arg1 = (wxWindow *) 0 ;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 PyObject *swig_obj[1] ;
35378
35379 if (!args) SWIG_fail;
35380 swig_obj[0] = args;
35381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35384 }
35385 arg1 = reinterpret_cast< wxWindow * >(argp1);
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 (arg1)->ReleaseMouse();
35389 wxPyEndAllowThreads(__tstate);
35390 if (PyErr_Occurred()) SWIG_fail;
35391 }
35392 resultobj = SWIG_Py_Void();
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35400 PyObject *resultobj = 0;
35401 wxWindow *result = 0 ;
35402
35403 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35404 {
35405 if (!wxPyCheckForApp()) SWIG_fail;
35406 PyThreadState* __tstate = wxPyBeginAllowThreads();
35407 result = (wxWindow *)wxWindow::GetCapture();
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 {
35412 resultobj = wxPyMake_wxObject(result, 0);
35413 }
35414 return resultobj;
35415 fail:
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 bool result;
35424 void *argp1 = 0 ;
35425 int res1 = 0 ;
35426 PyObject *swig_obj[1] ;
35427
35428 if (!args) SWIG_fail;
35429 swig_obj[0] = args;
35430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35431 if (!SWIG_IsOK(res1)) {
35432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35433 }
35434 arg1 = reinterpret_cast< wxWindow * >(argp1);
35435 {
35436 PyThreadState* __tstate = wxPyBeginAllowThreads();
35437 result = (bool)((wxWindow const *)arg1)->HasCapture();
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 {
35442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35443 }
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35451 PyObject *resultobj = 0;
35452 wxWindow *arg1 = (wxWindow *) 0 ;
35453 bool arg2 = (bool) true ;
35454 wxRect *arg3 = (wxRect *) NULL ;
35455 void *argp1 = 0 ;
35456 int res1 = 0 ;
35457 bool val2 ;
35458 int ecode2 = 0 ;
35459 void *argp3 = 0 ;
35460 int res3 = 0 ;
35461 PyObject * obj0 = 0 ;
35462 PyObject * obj1 = 0 ;
35463 PyObject * obj2 = 0 ;
35464 char * kwnames[] = {
35465 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35466 };
35467
35468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35470 if (!SWIG_IsOK(res1)) {
35471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35472 }
35473 arg1 = reinterpret_cast< wxWindow * >(argp1);
35474 if (obj1) {
35475 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35476 if (!SWIG_IsOK(ecode2)) {
35477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35478 }
35479 arg2 = static_cast< bool >(val2);
35480 }
35481 if (obj2) {
35482 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35483 if (!SWIG_IsOK(res3)) {
35484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35485 }
35486 arg3 = reinterpret_cast< wxRect * >(argp3);
35487 }
35488 {
35489 PyThreadState* __tstate = wxPyBeginAllowThreads();
35490 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 resultobj = SWIG_Py_Void();
35495 return resultobj;
35496 fail:
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 wxRect *arg2 = 0 ;
35505 bool arg3 = (bool) true ;
35506 void *argp1 = 0 ;
35507 int res1 = 0 ;
35508 wxRect temp2 ;
35509 bool val3 ;
35510 int ecode3 = 0 ;
35511 PyObject * obj0 = 0 ;
35512 PyObject * obj1 = 0 ;
35513 PyObject * obj2 = 0 ;
35514 char * kwnames[] = {
35515 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35516 };
35517
35518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35520 if (!SWIG_IsOK(res1)) {
35521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35522 }
35523 arg1 = reinterpret_cast< wxWindow * >(argp1);
35524 {
35525 arg2 = &temp2;
35526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35527 }
35528 if (obj2) {
35529 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35530 if (!SWIG_IsOK(ecode3)) {
35531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35532 }
35533 arg3 = static_cast< bool >(val3);
35534 }
35535 {
35536 PyThreadState* __tstate = wxPyBeginAllowThreads();
35537 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35538 wxPyEndAllowThreads(__tstate);
35539 if (PyErr_Occurred()) SWIG_fail;
35540 }
35541 resultobj = SWIG_Py_Void();
35542 return resultobj;
35543 fail:
35544 return NULL;
35545 }
35546
35547
35548 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35549 PyObject *resultobj = 0;
35550 wxWindow *arg1 = (wxWindow *) 0 ;
35551 void *argp1 = 0 ;
35552 int res1 = 0 ;
35553 PyObject *swig_obj[1] ;
35554
35555 if (!args) SWIG_fail;
35556 swig_obj[0] = args;
35557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35558 if (!SWIG_IsOK(res1)) {
35559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35560 }
35561 arg1 = reinterpret_cast< wxWindow * >(argp1);
35562 {
35563 PyThreadState* __tstate = wxPyBeginAllowThreads();
35564 (arg1)->Update();
35565 wxPyEndAllowThreads(__tstate);
35566 if (PyErr_Occurred()) SWIG_fail;
35567 }
35568 resultobj = SWIG_Py_Void();
35569 return resultobj;
35570 fail:
35571 return NULL;
35572 }
35573
35574
35575 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35576 PyObject *resultobj = 0;
35577 wxWindow *arg1 = (wxWindow *) 0 ;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 PyObject *swig_obj[1] ;
35581
35582 if (!args) SWIG_fail;
35583 swig_obj[0] = args;
35584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35585 if (!SWIG_IsOK(res1)) {
35586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35587 }
35588 arg1 = reinterpret_cast< wxWindow * >(argp1);
35589 {
35590 PyThreadState* __tstate = wxPyBeginAllowThreads();
35591 (arg1)->ClearBackground();
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 resultobj = SWIG_Py_Void();
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35603 PyObject *resultobj = 0;
35604 wxWindow *arg1 = (wxWindow *) 0 ;
35605 void *argp1 = 0 ;
35606 int res1 = 0 ;
35607 PyObject *swig_obj[1] ;
35608
35609 if (!args) SWIG_fail;
35610 swig_obj[0] = args;
35611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35612 if (!SWIG_IsOK(res1)) {
35613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35614 }
35615 arg1 = reinterpret_cast< wxWindow * >(argp1);
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 (arg1)->Freeze();
35619 wxPyEndAllowThreads(__tstate);
35620 if (PyErr_Occurred()) SWIG_fail;
35621 }
35622 resultobj = SWIG_Py_Void();
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35630 PyObject *resultobj = 0;
35631 wxWindow *arg1 = (wxWindow *) 0 ;
35632 bool result;
35633 void *argp1 = 0 ;
35634 int res1 = 0 ;
35635 PyObject *swig_obj[1] ;
35636
35637 if (!args) SWIG_fail;
35638 swig_obj[0] = args;
35639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35640 if (!SWIG_IsOK(res1)) {
35641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35642 }
35643 arg1 = reinterpret_cast< wxWindow * >(argp1);
35644 {
35645 PyThreadState* __tstate = wxPyBeginAllowThreads();
35646 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35647 wxPyEndAllowThreads(__tstate);
35648 if (PyErr_Occurred()) SWIG_fail;
35649 }
35650 {
35651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35652 }
35653 return resultobj;
35654 fail:
35655 return NULL;
35656 }
35657
35658
35659 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35660 PyObject *resultobj = 0;
35661 wxWindow *arg1 = (wxWindow *) 0 ;
35662 void *argp1 = 0 ;
35663 int res1 = 0 ;
35664 PyObject *swig_obj[1] ;
35665
35666 if (!args) SWIG_fail;
35667 swig_obj[0] = args;
35668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35669 if (!SWIG_IsOK(res1)) {
35670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35671 }
35672 arg1 = reinterpret_cast< wxWindow * >(argp1);
35673 {
35674 PyThreadState* __tstate = wxPyBeginAllowThreads();
35675 (arg1)->Thaw();
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 resultobj = SWIG_Py_Void();
35680 return resultobj;
35681 fail:
35682 return NULL;
35683 }
35684
35685
35686 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35687 PyObject *resultobj = 0;
35688 wxWindow *arg1 = (wxWindow *) 0 ;
35689 wxDC *arg2 = 0 ;
35690 void *argp1 = 0 ;
35691 int res1 = 0 ;
35692 void *argp2 = 0 ;
35693 int res2 = 0 ;
35694 PyObject * obj0 = 0 ;
35695 PyObject * obj1 = 0 ;
35696 char * kwnames[] = {
35697 (char *) "self",(char *) "dc", NULL
35698 };
35699
35700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35702 if (!SWIG_IsOK(res1)) {
35703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35704 }
35705 arg1 = reinterpret_cast< wxWindow * >(argp1);
35706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35707 if (!SWIG_IsOK(res2)) {
35708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35709 }
35710 if (!argp2) {
35711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35712 }
35713 arg2 = reinterpret_cast< wxDC * >(argp2);
35714 {
35715 PyThreadState* __tstate = wxPyBeginAllowThreads();
35716 (arg1)->PrepareDC(*arg2);
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 resultobj = SWIG_Py_Void();
35721 return resultobj;
35722 fail:
35723 return NULL;
35724 }
35725
35726
35727 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35728 PyObject *resultobj = 0;
35729 wxWindow *arg1 = (wxWindow *) 0 ;
35730 bool result;
35731 void *argp1 = 0 ;
35732 int res1 = 0 ;
35733 PyObject *swig_obj[1] ;
35734
35735 if (!args) SWIG_fail;
35736 swig_obj[0] = args;
35737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35738 if (!SWIG_IsOK(res1)) {
35739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35740 }
35741 arg1 = reinterpret_cast< wxWindow * >(argp1);
35742 {
35743 PyThreadState* __tstate = wxPyBeginAllowThreads();
35744 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35745 wxPyEndAllowThreads(__tstate);
35746 if (PyErr_Occurred()) SWIG_fail;
35747 }
35748 {
35749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35750 }
35751 return resultobj;
35752 fail:
35753 return NULL;
35754 }
35755
35756
35757 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35758 PyObject *resultobj = 0;
35759 wxWindow *arg1 = (wxWindow *) 0 ;
35760 wxRegion *result = 0 ;
35761 void *argp1 = 0 ;
35762 int res1 = 0 ;
35763 PyObject *swig_obj[1] ;
35764
35765 if (!args) SWIG_fail;
35766 swig_obj[0] = args;
35767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35768 if (!SWIG_IsOK(res1)) {
35769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35770 }
35771 arg1 = reinterpret_cast< wxWindow * >(argp1);
35772 {
35773 PyThreadState* __tstate = wxPyBeginAllowThreads();
35774 {
35775 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35776 result = (wxRegion *) &_result_ref;
35777 }
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35782 return resultobj;
35783 fail:
35784 return NULL;
35785 }
35786
35787
35788 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35789 PyObject *resultobj = 0;
35790 wxWindow *arg1 = (wxWindow *) 0 ;
35791 wxRect result;
35792 void *argp1 = 0 ;
35793 int res1 = 0 ;
35794 PyObject *swig_obj[1] ;
35795
35796 if (!args) SWIG_fail;
35797 swig_obj[0] = args;
35798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35799 if (!SWIG_IsOK(res1)) {
35800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35801 }
35802 arg1 = reinterpret_cast< wxWindow * >(argp1);
35803 {
35804 PyThreadState* __tstate = wxPyBeginAllowThreads();
35805 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35806 wxPyEndAllowThreads(__tstate);
35807 if (PyErr_Occurred()) SWIG_fail;
35808 }
35809 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35810 return resultobj;
35811 fail:
35812 return NULL;
35813 }
35814
35815
35816 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35817 PyObject *resultobj = 0;
35818 wxWindow *arg1 = (wxWindow *) 0 ;
35819 int arg2 ;
35820 int arg3 ;
35821 int arg4 = (int) 1 ;
35822 int arg5 = (int) 1 ;
35823 bool result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 int val2 ;
35827 int ecode2 = 0 ;
35828 int val3 ;
35829 int ecode3 = 0 ;
35830 int val4 ;
35831 int ecode4 = 0 ;
35832 int val5 ;
35833 int ecode5 = 0 ;
35834 PyObject * obj0 = 0 ;
35835 PyObject * obj1 = 0 ;
35836 PyObject * obj2 = 0 ;
35837 PyObject * obj3 = 0 ;
35838 PyObject * obj4 = 0 ;
35839 char * kwnames[] = {
35840 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35841 };
35842
35843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35845 if (!SWIG_IsOK(res1)) {
35846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35847 }
35848 arg1 = reinterpret_cast< wxWindow * >(argp1);
35849 ecode2 = SWIG_AsVal_int(obj1, &val2);
35850 if (!SWIG_IsOK(ecode2)) {
35851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35852 }
35853 arg2 = static_cast< int >(val2);
35854 ecode3 = SWIG_AsVal_int(obj2, &val3);
35855 if (!SWIG_IsOK(ecode3)) {
35856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35857 }
35858 arg3 = static_cast< int >(val3);
35859 if (obj3) {
35860 ecode4 = SWIG_AsVal_int(obj3, &val4);
35861 if (!SWIG_IsOK(ecode4)) {
35862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35863 }
35864 arg4 = static_cast< int >(val4);
35865 }
35866 if (obj4) {
35867 ecode5 = SWIG_AsVal_int(obj4, &val5);
35868 if (!SWIG_IsOK(ecode5)) {
35869 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35870 }
35871 arg5 = static_cast< int >(val5);
35872 }
35873 {
35874 PyThreadState* __tstate = wxPyBeginAllowThreads();
35875 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35876 wxPyEndAllowThreads(__tstate);
35877 if (PyErr_Occurred()) SWIG_fail;
35878 }
35879 {
35880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35881 }
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 wxPoint *arg2 = 0 ;
35892 bool result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 wxPoint temp2 ;
35896 PyObject * obj0 = 0 ;
35897 PyObject * obj1 = 0 ;
35898 char * kwnames[] = {
35899 (char *) "self",(char *) "pt", NULL
35900 };
35901
35902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35904 if (!SWIG_IsOK(res1)) {
35905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35906 }
35907 arg1 = reinterpret_cast< wxWindow * >(argp1);
35908 {
35909 arg2 = &temp2;
35910 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35911 }
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 {
35919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35920 }
35921 return resultobj;
35922 fail:
35923 return NULL;
35924 }
35925
35926
35927 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35928 PyObject *resultobj = 0;
35929 wxWindow *arg1 = (wxWindow *) 0 ;
35930 wxRect *arg2 = 0 ;
35931 bool result;
35932 void *argp1 = 0 ;
35933 int res1 = 0 ;
35934 wxRect temp2 ;
35935 PyObject * obj0 = 0 ;
35936 PyObject * obj1 = 0 ;
35937 char * kwnames[] = {
35938 (char *) "self",(char *) "rect", NULL
35939 };
35940
35941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35943 if (!SWIG_IsOK(res1)) {
35944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35945 }
35946 arg1 = reinterpret_cast< wxWindow * >(argp1);
35947 {
35948 arg2 = &temp2;
35949 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35950 }
35951 {
35952 PyThreadState* __tstate = wxPyBeginAllowThreads();
35953 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35954 wxPyEndAllowThreads(__tstate);
35955 if (PyErr_Occurred()) SWIG_fail;
35956 }
35957 {
35958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35959 }
35960 return resultobj;
35961 fail:
35962 return NULL;
35963 }
35964
35965
35966 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35967 PyObject *resultobj = 0;
35968 wxWindow *arg1 = (wxWindow *) 0 ;
35969 SwigValueWrapper<wxVisualAttributes > result;
35970 void *argp1 = 0 ;
35971 int res1 = 0 ;
35972 PyObject *swig_obj[1] ;
35973
35974 if (!args) SWIG_fail;
35975 swig_obj[0] = args;
35976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35977 if (!SWIG_IsOK(res1)) {
35978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35979 }
35980 arg1 = reinterpret_cast< wxWindow * >(argp1);
35981 {
35982 PyThreadState* __tstate = wxPyBeginAllowThreads();
35983 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35984 wxPyEndAllowThreads(__tstate);
35985 if (PyErr_Occurred()) SWIG_fail;
35986 }
35987 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35988 return resultobj;
35989 fail:
35990 return NULL;
35991 }
35992
35993
35994 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35995 PyObject *resultobj = 0;
35996 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35997 SwigValueWrapper<wxVisualAttributes > result;
35998 int val1 ;
35999 int ecode1 = 0 ;
36000 PyObject * obj0 = 0 ;
36001 char * kwnames[] = {
36002 (char *) "variant", NULL
36003 };
36004
36005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36006 if (obj0) {
36007 ecode1 = SWIG_AsVal_int(obj0, &val1);
36008 if (!SWIG_IsOK(ecode1)) {
36009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36010 }
36011 arg1 = static_cast< wxWindowVariant >(val1);
36012 }
36013 {
36014 if (!wxPyCheckForApp()) SWIG_fail;
36015 PyThreadState* __tstate = wxPyBeginAllowThreads();
36016 result = wxWindow::GetClassDefaultAttributes(arg1);
36017 wxPyEndAllowThreads(__tstate);
36018 if (PyErr_Occurred()) SWIG_fail;
36019 }
36020 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36021 return resultobj;
36022 fail:
36023 return NULL;
36024 }
36025
36026
36027 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36028 PyObject *resultobj = 0;
36029 wxWindow *arg1 = (wxWindow *) 0 ;
36030 wxColour *arg2 = 0 ;
36031 bool result;
36032 void *argp1 = 0 ;
36033 int res1 = 0 ;
36034 wxColour temp2 ;
36035 PyObject * obj0 = 0 ;
36036 PyObject * obj1 = 0 ;
36037 char * kwnames[] = {
36038 (char *) "self",(char *) "colour", NULL
36039 };
36040
36041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36043 if (!SWIG_IsOK(res1)) {
36044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36045 }
36046 arg1 = reinterpret_cast< wxWindow * >(argp1);
36047 {
36048 arg2 = &temp2;
36049 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36050 }
36051 {
36052 PyThreadState* __tstate = wxPyBeginAllowThreads();
36053 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36054 wxPyEndAllowThreads(__tstate);
36055 if (PyErr_Occurred()) SWIG_fail;
36056 }
36057 {
36058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36059 }
36060 return resultobj;
36061 fail:
36062 return NULL;
36063 }
36064
36065
36066 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36067 PyObject *resultobj = 0;
36068 wxWindow *arg1 = (wxWindow *) 0 ;
36069 wxColour *arg2 = 0 ;
36070 void *argp1 = 0 ;
36071 int res1 = 0 ;
36072 wxColour temp2 ;
36073 PyObject * obj0 = 0 ;
36074 PyObject * obj1 = 0 ;
36075 char * kwnames[] = {
36076 (char *) "self",(char *) "colour", NULL
36077 };
36078
36079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36081 if (!SWIG_IsOK(res1)) {
36082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36083 }
36084 arg1 = reinterpret_cast< wxWindow * >(argp1);
36085 {
36086 arg2 = &temp2;
36087 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36088 }
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36092 wxPyEndAllowThreads(__tstate);
36093 if (PyErr_Occurred()) SWIG_fail;
36094 }
36095 resultobj = SWIG_Py_Void();
36096 return resultobj;
36097 fail:
36098 return NULL;
36099 }
36100
36101
36102 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36103 PyObject *resultobj = 0;
36104 wxWindow *arg1 = (wxWindow *) 0 ;
36105 wxColour *arg2 = 0 ;
36106 bool result;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 wxColour temp2 ;
36110 PyObject * obj0 = 0 ;
36111 PyObject * obj1 = 0 ;
36112 char * kwnames[] = {
36113 (char *) "self",(char *) "colour", NULL
36114 };
36115
36116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36118 if (!SWIG_IsOK(res1)) {
36119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36120 }
36121 arg1 = reinterpret_cast< wxWindow * >(argp1);
36122 {
36123 arg2 = &temp2;
36124 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36125 }
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 {
36133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36134 }
36135 return resultobj;
36136 fail:
36137 return NULL;
36138 }
36139
36140
36141 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36142 PyObject *resultobj = 0;
36143 wxWindow *arg1 = (wxWindow *) 0 ;
36144 wxColour *arg2 = 0 ;
36145 void *argp1 = 0 ;
36146 int res1 = 0 ;
36147 wxColour temp2 ;
36148 PyObject * obj0 = 0 ;
36149 PyObject * obj1 = 0 ;
36150 char * kwnames[] = {
36151 (char *) "self",(char *) "colour", NULL
36152 };
36153
36154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36156 if (!SWIG_IsOK(res1)) {
36157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36158 }
36159 arg1 = reinterpret_cast< wxWindow * >(argp1);
36160 {
36161 arg2 = &temp2;
36162 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36163 }
36164 {
36165 PyThreadState* __tstate = wxPyBeginAllowThreads();
36166 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36167 wxPyEndAllowThreads(__tstate);
36168 if (PyErr_Occurred()) SWIG_fail;
36169 }
36170 resultobj = SWIG_Py_Void();
36171 return resultobj;
36172 fail:
36173 return NULL;
36174 }
36175
36176
36177 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36178 PyObject *resultobj = 0;
36179 wxWindow *arg1 = (wxWindow *) 0 ;
36180 wxColour result;
36181 void *argp1 = 0 ;
36182 int res1 = 0 ;
36183 PyObject *swig_obj[1] ;
36184
36185 if (!args) SWIG_fail;
36186 swig_obj[0] = args;
36187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36188 if (!SWIG_IsOK(res1)) {
36189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36190 }
36191 arg1 = reinterpret_cast< wxWindow * >(argp1);
36192 {
36193 PyThreadState* __tstate = wxPyBeginAllowThreads();
36194 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36195 wxPyEndAllowThreads(__tstate);
36196 if (PyErr_Occurred()) SWIG_fail;
36197 }
36198 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36199 return resultobj;
36200 fail:
36201 return NULL;
36202 }
36203
36204
36205 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36206 PyObject *resultobj = 0;
36207 wxWindow *arg1 = (wxWindow *) 0 ;
36208 wxColour result;
36209 void *argp1 = 0 ;
36210 int res1 = 0 ;
36211 PyObject *swig_obj[1] ;
36212
36213 if (!args) SWIG_fail;
36214 swig_obj[0] = args;
36215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36218 }
36219 arg1 = reinterpret_cast< wxWindow * >(argp1);
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 result = ((wxWindow const *)arg1)->GetForegroundColour();
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36234 PyObject *resultobj = 0;
36235 wxWindow *arg1 = (wxWindow *) 0 ;
36236 bool result;
36237 void *argp1 = 0 ;
36238 int res1 = 0 ;
36239 PyObject *swig_obj[1] ;
36240
36241 if (!args) SWIG_fail;
36242 swig_obj[0] = args;
36243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36244 if (!SWIG_IsOK(res1)) {
36245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36246 }
36247 arg1 = reinterpret_cast< wxWindow * >(argp1);
36248 {
36249 PyThreadState* __tstate = wxPyBeginAllowThreads();
36250 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36251 wxPyEndAllowThreads(__tstate);
36252 if (PyErr_Occurred()) SWIG_fail;
36253 }
36254 {
36255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36256 }
36257 return resultobj;
36258 fail:
36259 return NULL;
36260 }
36261
36262
36263 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36264 PyObject *resultobj = 0;
36265 wxWindow *arg1 = (wxWindow *) 0 ;
36266 bool result;
36267 void *argp1 = 0 ;
36268 int res1 = 0 ;
36269 PyObject *swig_obj[1] ;
36270
36271 if (!args) SWIG_fail;
36272 swig_obj[0] = args;
36273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36274 if (!SWIG_IsOK(res1)) {
36275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36276 }
36277 arg1 = reinterpret_cast< wxWindow * >(argp1);
36278 {
36279 PyThreadState* __tstate = wxPyBeginAllowThreads();
36280 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36281 wxPyEndAllowThreads(__tstate);
36282 if (PyErr_Occurred()) SWIG_fail;
36283 }
36284 {
36285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36286 }
36287 return resultobj;
36288 fail:
36289 return NULL;
36290 }
36291
36292
36293 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36294 PyObject *resultobj = 0;
36295 wxWindow *arg1 = (wxWindow *) 0 ;
36296 wxBackgroundStyle arg2 ;
36297 bool result;
36298 void *argp1 = 0 ;
36299 int res1 = 0 ;
36300 int val2 ;
36301 int ecode2 = 0 ;
36302 PyObject * obj0 = 0 ;
36303 PyObject * obj1 = 0 ;
36304 char * kwnames[] = {
36305 (char *) "self",(char *) "style", NULL
36306 };
36307
36308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36310 if (!SWIG_IsOK(res1)) {
36311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36312 }
36313 arg1 = reinterpret_cast< wxWindow * >(argp1);
36314 ecode2 = SWIG_AsVal_int(obj1, &val2);
36315 if (!SWIG_IsOK(ecode2)) {
36316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36317 }
36318 arg2 = static_cast< wxBackgroundStyle >(val2);
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36322 wxPyEndAllowThreads(__tstate);
36323 if (PyErr_Occurred()) SWIG_fail;
36324 }
36325 {
36326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36327 }
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 wxBackgroundStyle result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36347 }
36348 arg1 = reinterpret_cast< wxWindow * >(argp1);
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 resultobj = SWIG_From_int(static_cast< int >(result));
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36363 PyObject *resultobj = 0;
36364 wxWindow *arg1 = (wxWindow *) 0 ;
36365 bool result;
36366 void *argp1 = 0 ;
36367 int res1 = 0 ;
36368 PyObject *swig_obj[1] ;
36369
36370 if (!args) SWIG_fail;
36371 swig_obj[0] = args;
36372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36373 if (!SWIG_IsOK(res1)) {
36374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36375 }
36376 arg1 = reinterpret_cast< wxWindow * >(argp1);
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = (bool)(arg1)->HasTransparentBackground();
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj = 0;
36394 wxWindow *arg1 = (wxWindow *) 0 ;
36395 wxCursor *arg2 = 0 ;
36396 bool result;
36397 void *argp1 = 0 ;
36398 int res1 = 0 ;
36399 void *argp2 = 0 ;
36400 int res2 = 0 ;
36401 PyObject * obj0 = 0 ;
36402 PyObject * obj1 = 0 ;
36403 char * kwnames[] = {
36404 (char *) "self",(char *) "cursor", NULL
36405 };
36406
36407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36409 if (!SWIG_IsOK(res1)) {
36410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36411 }
36412 arg1 = reinterpret_cast< wxWindow * >(argp1);
36413 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36414 if (!SWIG_IsOK(res2)) {
36415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36416 }
36417 if (!argp2) {
36418 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36419 }
36420 arg2 = reinterpret_cast< wxCursor * >(argp2);
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 {
36428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36429 }
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36437 PyObject *resultobj = 0;
36438 wxWindow *arg1 = (wxWindow *) 0 ;
36439 wxCursor result;
36440 void *argp1 = 0 ;
36441 int res1 = 0 ;
36442 PyObject *swig_obj[1] ;
36443
36444 if (!args) SWIG_fail;
36445 swig_obj[0] = args;
36446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 result = (arg1)->GetCursor();
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36458 return resultobj;
36459 fail:
36460 return NULL;
36461 }
36462
36463
36464 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36465 PyObject *resultobj = 0;
36466 wxWindow *arg1 = (wxWindow *) 0 ;
36467 wxFont *arg2 = 0 ;
36468 bool result;
36469 void *argp1 = 0 ;
36470 int res1 = 0 ;
36471 void *argp2 = 0 ;
36472 int res2 = 0 ;
36473 PyObject * obj0 = 0 ;
36474 PyObject * obj1 = 0 ;
36475 char * kwnames[] = {
36476 (char *) "self",(char *) "font", NULL
36477 };
36478
36479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36481 if (!SWIG_IsOK(res1)) {
36482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36483 }
36484 arg1 = reinterpret_cast< wxWindow * >(argp1);
36485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36486 if (!SWIG_IsOK(res2)) {
36487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36488 }
36489 if (!argp2) {
36490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36491 }
36492 arg2 = reinterpret_cast< wxFont * >(argp2);
36493 {
36494 PyThreadState* __tstate = wxPyBeginAllowThreads();
36495 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36496 wxPyEndAllowThreads(__tstate);
36497 if (PyErr_Occurred()) SWIG_fail;
36498 }
36499 {
36500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36501 }
36502 return resultobj;
36503 fail:
36504 return NULL;
36505 }
36506
36507
36508 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36509 PyObject *resultobj = 0;
36510 wxWindow *arg1 = (wxWindow *) 0 ;
36511 wxFont *arg2 = 0 ;
36512 void *argp1 = 0 ;
36513 int res1 = 0 ;
36514 void *argp2 = 0 ;
36515 int res2 = 0 ;
36516 PyObject * obj0 = 0 ;
36517 PyObject * obj1 = 0 ;
36518 char * kwnames[] = {
36519 (char *) "self",(char *) "font", NULL
36520 };
36521
36522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36524 if (!SWIG_IsOK(res1)) {
36525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36526 }
36527 arg1 = reinterpret_cast< wxWindow * >(argp1);
36528 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36529 if (!SWIG_IsOK(res2)) {
36530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36531 }
36532 if (!argp2) {
36533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36534 }
36535 arg2 = reinterpret_cast< wxFont * >(argp2);
36536 {
36537 PyThreadState* __tstate = wxPyBeginAllowThreads();
36538 (arg1)->SetOwnFont((wxFont const &)*arg2);
36539 wxPyEndAllowThreads(__tstate);
36540 if (PyErr_Occurred()) SWIG_fail;
36541 }
36542 resultobj = SWIG_Py_Void();
36543 return resultobj;
36544 fail:
36545 return NULL;
36546 }
36547
36548
36549 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36550 PyObject *resultobj = 0;
36551 wxWindow *arg1 = (wxWindow *) 0 ;
36552 wxFont result;
36553 void *argp1 = 0 ;
36554 int res1 = 0 ;
36555 PyObject *swig_obj[1] ;
36556
36557 if (!args) SWIG_fail;
36558 swig_obj[0] = args;
36559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36560 if (!SWIG_IsOK(res1)) {
36561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36562 }
36563 arg1 = reinterpret_cast< wxWindow * >(argp1);
36564 {
36565 PyThreadState* __tstate = wxPyBeginAllowThreads();
36566 result = (arg1)->GetFont();
36567 wxPyEndAllowThreads(__tstate);
36568 if (PyErr_Occurred()) SWIG_fail;
36569 }
36570 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36571 return resultobj;
36572 fail:
36573 return NULL;
36574 }
36575
36576
36577 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36578 PyObject *resultobj = 0;
36579 wxWindow *arg1 = (wxWindow *) 0 ;
36580 wxCaret *arg2 = (wxCaret *) 0 ;
36581 void *argp1 = 0 ;
36582 int res1 = 0 ;
36583 int res2 = 0 ;
36584 PyObject * obj0 = 0 ;
36585 PyObject * obj1 = 0 ;
36586 char * kwnames[] = {
36587 (char *) "self",(char *) "caret", NULL
36588 };
36589
36590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36592 if (!SWIG_IsOK(res1)) {
36593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36594 }
36595 arg1 = reinterpret_cast< wxWindow * >(argp1);
36596 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36597 if (!SWIG_IsOK(res2)) {
36598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36599 }
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 (arg1)->SetCaret(arg2);
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 resultobj = SWIG_Py_Void();
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36614 PyObject *resultobj = 0;
36615 wxWindow *arg1 = (wxWindow *) 0 ;
36616 wxCaret *result = 0 ;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 PyObject *swig_obj[1] ;
36620
36621 if (!args) SWIG_fail;
36622 swig_obj[0] = args;
36623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36626 }
36627 arg1 = reinterpret_cast< wxWindow * >(argp1);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36642 PyObject *resultobj = 0;
36643 wxWindow *arg1 = (wxWindow *) 0 ;
36644 int result;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 PyObject *swig_obj[1] ;
36648
36649 if (!args) SWIG_fail;
36650 swig_obj[0] = args;
36651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36652 if (!SWIG_IsOK(res1)) {
36653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36654 }
36655 arg1 = reinterpret_cast< wxWindow * >(argp1);
36656 {
36657 PyThreadState* __tstate = wxPyBeginAllowThreads();
36658 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 resultobj = SWIG_From_int(static_cast< int >(result));
36663 return resultobj;
36664 fail:
36665 return NULL;
36666 }
36667
36668
36669 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36670 PyObject *resultobj = 0;
36671 wxWindow *arg1 = (wxWindow *) 0 ;
36672 int result;
36673 void *argp1 = 0 ;
36674 int res1 = 0 ;
36675 PyObject *swig_obj[1] ;
36676
36677 if (!args) SWIG_fail;
36678 swig_obj[0] = args;
36679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36680 if (!SWIG_IsOK(res1)) {
36681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36682 }
36683 arg1 = reinterpret_cast< wxWindow * >(argp1);
36684 {
36685 PyThreadState* __tstate = wxPyBeginAllowThreads();
36686 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36687 wxPyEndAllowThreads(__tstate);
36688 if (PyErr_Occurred()) SWIG_fail;
36689 }
36690 resultobj = SWIG_From_int(static_cast< int >(result));
36691 return resultobj;
36692 fail:
36693 return NULL;
36694 }
36695
36696
36697 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36698 PyObject *resultobj = 0;
36699 wxWindow *arg1 = (wxWindow *) 0 ;
36700 wxString *arg2 = 0 ;
36701 int *arg3 = (int *) 0 ;
36702 int *arg4 = (int *) 0 ;
36703 void *argp1 = 0 ;
36704 int res1 = 0 ;
36705 bool temp2 = false ;
36706 int temp3 ;
36707 int res3 = SWIG_TMPOBJ ;
36708 int temp4 ;
36709 int res4 = SWIG_TMPOBJ ;
36710 PyObject * obj0 = 0 ;
36711 PyObject * obj1 = 0 ;
36712 char * kwnames[] = {
36713 (char *) "self",(char *) "string", NULL
36714 };
36715
36716 arg3 = &temp3;
36717 arg4 = &temp4;
36718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36720 if (!SWIG_IsOK(res1)) {
36721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36722 }
36723 arg1 = reinterpret_cast< wxWindow * >(argp1);
36724 {
36725 arg2 = wxString_in_helper(obj1);
36726 if (arg2 == NULL) SWIG_fail;
36727 temp2 = true;
36728 }
36729 {
36730 PyThreadState* __tstate = wxPyBeginAllowThreads();
36731 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 resultobj = SWIG_Py_Void();
36736 if (SWIG_IsTmpObj(res3)) {
36737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36738 } else {
36739 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36741 }
36742 if (SWIG_IsTmpObj(res4)) {
36743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36744 } else {
36745 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36747 }
36748 {
36749 if (temp2)
36750 delete arg2;
36751 }
36752 return resultobj;
36753 fail:
36754 {
36755 if (temp2)
36756 delete arg2;
36757 }
36758 return NULL;
36759 }
36760
36761
36762 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj = 0;
36764 wxWindow *arg1 = (wxWindow *) 0 ;
36765 wxString *arg2 = 0 ;
36766 int *arg3 = (int *) 0 ;
36767 int *arg4 = (int *) 0 ;
36768 int *arg5 = (int *) 0 ;
36769 int *arg6 = (int *) 0 ;
36770 wxFont *arg7 = (wxFont *) NULL ;
36771 void *argp1 = 0 ;
36772 int res1 = 0 ;
36773 bool temp2 = false ;
36774 int temp3 ;
36775 int res3 = SWIG_TMPOBJ ;
36776 int temp4 ;
36777 int res4 = SWIG_TMPOBJ ;
36778 int temp5 ;
36779 int res5 = SWIG_TMPOBJ ;
36780 int temp6 ;
36781 int res6 = SWIG_TMPOBJ ;
36782 void *argp7 = 0 ;
36783 int res7 = 0 ;
36784 PyObject * obj0 = 0 ;
36785 PyObject * obj1 = 0 ;
36786 PyObject * obj2 = 0 ;
36787 char * kwnames[] = {
36788 (char *) "self",(char *) "string",(char *) "font", NULL
36789 };
36790
36791 arg3 = &temp3;
36792 arg4 = &temp4;
36793 arg5 = &temp5;
36794 arg6 = &temp6;
36795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36797 if (!SWIG_IsOK(res1)) {
36798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36799 }
36800 arg1 = reinterpret_cast< wxWindow * >(argp1);
36801 {
36802 arg2 = wxString_in_helper(obj1);
36803 if (arg2 == NULL) SWIG_fail;
36804 temp2 = true;
36805 }
36806 if (obj2) {
36807 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36808 if (!SWIG_IsOK(res7)) {
36809 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36810 }
36811 arg7 = reinterpret_cast< wxFont * >(argp7);
36812 }
36813 {
36814 PyThreadState* __tstate = wxPyBeginAllowThreads();
36815 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36816 wxPyEndAllowThreads(__tstate);
36817 if (PyErr_Occurred()) SWIG_fail;
36818 }
36819 resultobj = SWIG_Py_Void();
36820 if (SWIG_IsTmpObj(res3)) {
36821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36822 } else {
36823 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36825 }
36826 if (SWIG_IsTmpObj(res4)) {
36827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36828 } else {
36829 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36831 }
36832 if (SWIG_IsTmpObj(res5)) {
36833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36834 } else {
36835 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36837 }
36838 if (SWIG_IsTmpObj(res6)) {
36839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36840 } else {
36841 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36843 }
36844 {
36845 if (temp2)
36846 delete arg2;
36847 }
36848 return resultobj;
36849 fail:
36850 {
36851 if (temp2)
36852 delete arg2;
36853 }
36854 return NULL;
36855 }
36856
36857
36858 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj = 0;
36860 wxWindow *arg1 = (wxWindow *) 0 ;
36861 int *arg2 = (int *) 0 ;
36862 int *arg3 = (int *) 0 ;
36863 void *argp1 = 0 ;
36864 int res1 = 0 ;
36865 int temp2 ;
36866 int res2 = 0 ;
36867 int temp3 ;
36868 int res3 = 0 ;
36869 PyObject * obj0 = 0 ;
36870 PyObject * obj1 = 0 ;
36871 PyObject * obj2 = 0 ;
36872 char * kwnames[] = {
36873 (char *) "self",(char *) "x",(char *) "y", NULL
36874 };
36875
36876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36878 if (!SWIG_IsOK(res1)) {
36879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36880 }
36881 arg1 = reinterpret_cast< wxWindow * >(argp1);
36882 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36883 int val;
36884 int ecode = SWIG_AsVal_int(obj1, &val);
36885 if (!SWIG_IsOK(ecode)) {
36886 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36887 }
36888 temp2 = static_cast< int >(val);
36889 arg2 = &temp2;
36890 res2 = SWIG_AddTmpMask(ecode);
36891 }
36892 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36893 int val;
36894 int ecode = SWIG_AsVal_int(obj2, &val);
36895 if (!SWIG_IsOK(ecode)) {
36896 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36897 }
36898 temp3 = static_cast< int >(val);
36899 arg3 = &temp3;
36900 res3 = SWIG_AddTmpMask(ecode);
36901 }
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36905 wxPyEndAllowThreads(__tstate);
36906 if (PyErr_Occurred()) SWIG_fail;
36907 }
36908 resultobj = SWIG_Py_Void();
36909 if (SWIG_IsTmpObj(res2)) {
36910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36911 } else {
36912 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36914 }
36915 if (SWIG_IsTmpObj(res3)) {
36916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36917 } else {
36918 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36920 }
36921 return resultobj;
36922 fail:
36923 return NULL;
36924 }
36925
36926
36927 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36928 PyObject *resultobj = 0;
36929 wxWindow *arg1 = (wxWindow *) 0 ;
36930 int *arg2 = (int *) 0 ;
36931 int *arg3 = (int *) 0 ;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 int temp2 ;
36935 int res2 = 0 ;
36936 int temp3 ;
36937 int res3 = 0 ;
36938 PyObject * obj0 = 0 ;
36939 PyObject * obj1 = 0 ;
36940 PyObject * obj2 = 0 ;
36941 char * kwnames[] = {
36942 (char *) "self",(char *) "x",(char *) "y", NULL
36943 };
36944
36945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36947 if (!SWIG_IsOK(res1)) {
36948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36949 }
36950 arg1 = reinterpret_cast< wxWindow * >(argp1);
36951 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36952 int val;
36953 int ecode = SWIG_AsVal_int(obj1, &val);
36954 if (!SWIG_IsOK(ecode)) {
36955 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36956 }
36957 temp2 = static_cast< int >(val);
36958 arg2 = &temp2;
36959 res2 = SWIG_AddTmpMask(ecode);
36960 }
36961 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36962 int val;
36963 int ecode = SWIG_AsVal_int(obj2, &val);
36964 if (!SWIG_IsOK(ecode)) {
36965 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36966 }
36967 temp3 = static_cast< int >(val);
36968 arg3 = &temp3;
36969 res3 = SWIG_AddTmpMask(ecode);
36970 }
36971 {
36972 PyThreadState* __tstate = wxPyBeginAllowThreads();
36973 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36974 wxPyEndAllowThreads(__tstate);
36975 if (PyErr_Occurred()) SWIG_fail;
36976 }
36977 resultobj = SWIG_Py_Void();
36978 if (SWIG_IsTmpObj(res2)) {
36979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36980 } else {
36981 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36982 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36983 }
36984 if (SWIG_IsTmpObj(res3)) {
36985 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36986 } else {
36987 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36989 }
36990 return resultobj;
36991 fail:
36992 return NULL;
36993 }
36994
36995
36996 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36997 PyObject *resultobj = 0;
36998 wxWindow *arg1 = (wxWindow *) 0 ;
36999 wxPoint *arg2 = 0 ;
37000 wxPoint result;
37001 void *argp1 = 0 ;
37002 int res1 = 0 ;
37003 wxPoint temp2 ;
37004 PyObject * obj0 = 0 ;
37005 PyObject * obj1 = 0 ;
37006 char * kwnames[] = {
37007 (char *) "self",(char *) "pt", NULL
37008 };
37009
37010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37012 if (!SWIG_IsOK(res1)) {
37013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37014 }
37015 arg1 = reinterpret_cast< wxWindow * >(argp1);
37016 {
37017 arg2 = &temp2;
37018 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37019 }
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37027 return resultobj;
37028 fail:
37029 return NULL;
37030 }
37031
37032
37033 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37034 PyObject *resultobj = 0;
37035 wxWindow *arg1 = (wxWindow *) 0 ;
37036 wxPoint *arg2 = 0 ;
37037 wxPoint result;
37038 void *argp1 = 0 ;
37039 int res1 = 0 ;
37040 wxPoint temp2 ;
37041 PyObject * obj0 = 0 ;
37042 PyObject * obj1 = 0 ;
37043 char * kwnames[] = {
37044 (char *) "self",(char *) "pt", NULL
37045 };
37046
37047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37049 if (!SWIG_IsOK(res1)) {
37050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37051 }
37052 arg1 = reinterpret_cast< wxWindow * >(argp1);
37053 {
37054 arg2 = &temp2;
37055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37056 }
37057 {
37058 PyThreadState* __tstate = wxPyBeginAllowThreads();
37059 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37060 wxPyEndAllowThreads(__tstate);
37061 if (PyErr_Occurred()) SWIG_fail;
37062 }
37063 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 int arg2 ;
37074 int arg3 ;
37075 wxHitTest result;
37076 void *argp1 = 0 ;
37077 int res1 = 0 ;
37078 int val2 ;
37079 int ecode2 = 0 ;
37080 int val3 ;
37081 int ecode3 = 0 ;
37082 PyObject * obj0 = 0 ;
37083 PyObject * obj1 = 0 ;
37084 PyObject * obj2 = 0 ;
37085 char * kwnames[] = {
37086 (char *) "self",(char *) "x",(char *) "y", NULL
37087 };
37088
37089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37091 if (!SWIG_IsOK(res1)) {
37092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37093 }
37094 arg1 = reinterpret_cast< wxWindow * >(argp1);
37095 ecode2 = SWIG_AsVal_int(obj1, &val2);
37096 if (!SWIG_IsOK(ecode2)) {
37097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37098 }
37099 arg2 = static_cast< int >(val2);
37100 ecode3 = SWIG_AsVal_int(obj2, &val3);
37101 if (!SWIG_IsOK(ecode3)) {
37102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37103 }
37104 arg3 = static_cast< int >(val3);
37105 {
37106 PyThreadState* __tstate = wxPyBeginAllowThreads();
37107 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 resultobj = SWIG_From_int(static_cast< int >(result));
37112 return resultobj;
37113 fail:
37114 return NULL;
37115 }
37116
37117
37118 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37119 PyObject *resultobj = 0;
37120 wxWindow *arg1 = (wxWindow *) 0 ;
37121 wxPoint *arg2 = 0 ;
37122 wxHitTest result;
37123 void *argp1 = 0 ;
37124 int res1 = 0 ;
37125 wxPoint temp2 ;
37126 PyObject * obj0 = 0 ;
37127 PyObject * obj1 = 0 ;
37128 char * kwnames[] = {
37129 (char *) "self",(char *) "pt", NULL
37130 };
37131
37132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37134 if (!SWIG_IsOK(res1)) {
37135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37136 }
37137 arg1 = reinterpret_cast< wxWindow * >(argp1);
37138 {
37139 arg2 = &temp2;
37140 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37141 }
37142 {
37143 PyThreadState* __tstate = wxPyBeginAllowThreads();
37144 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37145 wxPyEndAllowThreads(__tstate);
37146 if (PyErr_Occurred()) SWIG_fail;
37147 }
37148 resultobj = SWIG_From_int(static_cast< int >(result));
37149 return resultobj;
37150 fail:
37151 return NULL;
37152 }
37153
37154
37155 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37156 PyObject *resultobj = 0;
37157 wxWindow *arg1 = (wxWindow *) 0 ;
37158 long arg2 ;
37159 wxBorder result;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 long val2 ;
37163 int ecode2 = 0 ;
37164
37165 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37167 if (!SWIG_IsOK(res1)) {
37168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37169 }
37170 arg1 = reinterpret_cast< wxWindow * >(argp1);
37171 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37172 if (!SWIG_IsOK(ecode2)) {
37173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37174 }
37175 arg2 = static_cast< long >(val2);
37176 {
37177 PyThreadState* __tstate = wxPyBeginAllowThreads();
37178 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37179 wxPyEndAllowThreads(__tstate);
37180 if (PyErr_Occurred()) SWIG_fail;
37181 }
37182 resultobj = SWIG_From_int(static_cast< int >(result));
37183 return resultobj;
37184 fail:
37185 return NULL;
37186 }
37187
37188
37189 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37190 PyObject *resultobj = 0;
37191 wxWindow *arg1 = (wxWindow *) 0 ;
37192 wxBorder result;
37193 void *argp1 = 0 ;
37194 int res1 = 0 ;
37195
37196 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37198 if (!SWIG_IsOK(res1)) {
37199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37200 }
37201 arg1 = reinterpret_cast< wxWindow * >(argp1);
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37205 wxPyEndAllowThreads(__tstate);
37206 if (PyErr_Occurred()) SWIG_fail;
37207 }
37208 resultobj = SWIG_From_int(static_cast< int >(result));
37209 return resultobj;
37210 fail:
37211 return NULL;
37212 }
37213
37214
37215 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37216 int argc;
37217 PyObject *argv[3];
37218
37219 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37220 --argc;
37221 if (argc == 1) {
37222 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37223 }
37224 if (argc == 2) {
37225 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37226 }
37227
37228 fail:
37229 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37230 return NULL;
37231 }
37232
37233
37234 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37235 PyObject *resultobj = 0;
37236 wxWindow *arg1 = (wxWindow *) 0 ;
37237 long arg2 = (long) wxUPDATE_UI_NONE ;
37238 void *argp1 = 0 ;
37239 int res1 = 0 ;
37240 long val2 ;
37241 int ecode2 = 0 ;
37242 PyObject * obj0 = 0 ;
37243 PyObject * obj1 = 0 ;
37244 char * kwnames[] = {
37245 (char *) "self",(char *) "flags", NULL
37246 };
37247
37248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37250 if (!SWIG_IsOK(res1)) {
37251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37252 }
37253 arg1 = reinterpret_cast< wxWindow * >(argp1);
37254 if (obj1) {
37255 ecode2 = SWIG_AsVal_long(obj1, &val2);
37256 if (!SWIG_IsOK(ecode2)) {
37257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37258 }
37259 arg2 = static_cast< long >(val2);
37260 }
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 (arg1)->UpdateWindowUI(arg2);
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 resultobj = SWIG_Py_Void();
37268 return resultobj;
37269 fail:
37270 return NULL;
37271 }
37272
37273
37274 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37275 PyObject *resultobj = 0;
37276 wxWindow *arg1 = (wxWindow *) 0 ;
37277 wxMenu *arg2 = (wxMenu *) 0 ;
37278 int arg3 = (int) -1 ;
37279 int arg4 = (int) -1 ;
37280 bool result;
37281 void *argp1 = 0 ;
37282 int res1 = 0 ;
37283 void *argp2 = 0 ;
37284 int res2 = 0 ;
37285 int val3 ;
37286 int ecode3 = 0 ;
37287 int val4 ;
37288 int ecode4 = 0 ;
37289 PyObject * obj0 = 0 ;
37290 PyObject * obj1 = 0 ;
37291 PyObject * obj2 = 0 ;
37292 PyObject * obj3 = 0 ;
37293 char * kwnames[] = {
37294 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37295 };
37296
37297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res1)) {
37300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37301 }
37302 arg1 = reinterpret_cast< wxWindow * >(argp1);
37303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37304 if (!SWIG_IsOK(res2)) {
37305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37306 }
37307 arg2 = reinterpret_cast< wxMenu * >(argp2);
37308 if (obj2) {
37309 ecode3 = SWIG_AsVal_int(obj2, &val3);
37310 if (!SWIG_IsOK(ecode3)) {
37311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37312 }
37313 arg3 = static_cast< int >(val3);
37314 }
37315 if (obj3) {
37316 ecode4 = SWIG_AsVal_int(obj3, &val4);
37317 if (!SWIG_IsOK(ecode4)) {
37318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37319 }
37320 arg4 = static_cast< int >(val4);
37321 }
37322 {
37323 PyThreadState* __tstate = wxPyBeginAllowThreads();
37324 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37325 wxPyEndAllowThreads(__tstate);
37326 if (PyErr_Occurred()) SWIG_fail;
37327 }
37328 {
37329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37330 }
37331 return resultobj;
37332 fail:
37333 return NULL;
37334 }
37335
37336
37337 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj = 0;
37339 wxWindow *arg1 = (wxWindow *) 0 ;
37340 wxMenu *arg2 = (wxMenu *) 0 ;
37341 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37342 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37343 bool result;
37344 void *argp1 = 0 ;
37345 int res1 = 0 ;
37346 void *argp2 = 0 ;
37347 int res2 = 0 ;
37348 wxPoint temp3 ;
37349 PyObject * obj0 = 0 ;
37350 PyObject * obj1 = 0 ;
37351 PyObject * obj2 = 0 ;
37352 char * kwnames[] = {
37353 (char *) "self",(char *) "menu",(char *) "pos", NULL
37354 };
37355
37356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37358 if (!SWIG_IsOK(res1)) {
37359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37360 }
37361 arg1 = reinterpret_cast< wxWindow * >(argp1);
37362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37363 if (!SWIG_IsOK(res2)) {
37364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37365 }
37366 arg2 = reinterpret_cast< wxMenu * >(argp2);
37367 if (obj2) {
37368 {
37369 arg3 = &temp3;
37370 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37371 }
37372 }
37373 {
37374 PyThreadState* __tstate = wxPyBeginAllowThreads();
37375 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37376 wxPyEndAllowThreads(__tstate);
37377 if (PyErr_Occurred()) SWIG_fail;
37378 }
37379 {
37380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37381 }
37382 return resultobj;
37383 fail:
37384 return NULL;
37385 }
37386
37387
37388 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37389 PyObject *resultobj = 0;
37390 wxWindow *arg1 = (wxWindow *) 0 ;
37391 bool result;
37392 void *argp1 = 0 ;
37393 int res1 = 0 ;
37394 PyObject *swig_obj[1] ;
37395
37396 if (!args) SWIG_fail;
37397 swig_obj[0] = args;
37398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37399 if (!SWIG_IsOK(res1)) {
37400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37401 }
37402 arg1 = reinterpret_cast< wxWindow * >(argp1);
37403 {
37404 PyThreadState* __tstate = wxPyBeginAllowThreads();
37405 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 {
37410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37411 }
37412 return resultobj;
37413 fail:
37414 return NULL;
37415 }
37416
37417
37418 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37419 PyObject *resultobj = 0;
37420 wxWindow *arg1 = (wxWindow *) 0 ;
37421 long result;
37422 void *argp1 = 0 ;
37423 int res1 = 0 ;
37424 PyObject *swig_obj[1] ;
37425
37426 if (!args) SWIG_fail;
37427 swig_obj[0] = args;
37428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37429 if (!SWIG_IsOK(res1)) {
37430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37431 }
37432 arg1 = reinterpret_cast< wxWindow * >(argp1);
37433 {
37434 PyThreadState* __tstate = wxPyBeginAllowThreads();
37435 result = (long)wxWindow_GetHandle(arg1);
37436 wxPyEndAllowThreads(__tstate);
37437 if (PyErr_Occurred()) SWIG_fail;
37438 }
37439 resultobj = SWIG_From_long(static_cast< long >(result));
37440 return resultobj;
37441 fail:
37442 return NULL;
37443 }
37444
37445
37446 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37447 PyObject *resultobj = 0;
37448 wxWindow *arg1 = (wxWindow *) 0 ;
37449 long arg2 ;
37450 void *argp1 = 0 ;
37451 int res1 = 0 ;
37452 long val2 ;
37453 int ecode2 = 0 ;
37454 PyObject * obj0 = 0 ;
37455 PyObject * obj1 = 0 ;
37456 char * kwnames[] = {
37457 (char *) "self",(char *) "handle", NULL
37458 };
37459
37460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37462 if (!SWIG_IsOK(res1)) {
37463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37464 }
37465 arg1 = reinterpret_cast< wxWindow * >(argp1);
37466 ecode2 = SWIG_AsVal_long(obj1, &val2);
37467 if (!SWIG_IsOK(ecode2)) {
37468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37469 }
37470 arg2 = static_cast< long >(val2);
37471 {
37472 PyThreadState* __tstate = wxPyBeginAllowThreads();
37473 wxWindow_AssociateHandle(arg1,arg2);
37474 wxPyEndAllowThreads(__tstate);
37475 if (PyErr_Occurred()) SWIG_fail;
37476 }
37477 resultobj = SWIG_Py_Void();
37478 return resultobj;
37479 fail:
37480 return NULL;
37481 }
37482
37483
37484 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37485 PyObject *resultobj = 0;
37486 wxWindow *arg1 = (wxWindow *) 0 ;
37487 void *argp1 = 0 ;
37488 int res1 = 0 ;
37489 PyObject *swig_obj[1] ;
37490
37491 if (!args) SWIG_fail;
37492 swig_obj[0] = args;
37493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37494 if (!SWIG_IsOK(res1)) {
37495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37496 }
37497 arg1 = reinterpret_cast< wxWindow * >(argp1);
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 (arg1)->DissociateHandle();
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 resultobj = SWIG_Py_Void();
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj = 0;
37513 wxWindow *arg1 = (wxWindow *) 0 ;
37514 wxPaintEvent *arg2 = 0 ;
37515 void *argp1 = 0 ;
37516 int res1 = 0 ;
37517 void *argp2 = 0 ;
37518 int res2 = 0 ;
37519 PyObject * obj0 = 0 ;
37520 PyObject * obj1 = 0 ;
37521 char * kwnames[] = {
37522 (char *) "self",(char *) "event", NULL
37523 };
37524
37525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
37526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37527 if (!SWIG_IsOK(res1)) {
37528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
37529 }
37530 arg1 = reinterpret_cast< wxWindow * >(argp1);
37531 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
37532 if (!SWIG_IsOK(res2)) {
37533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37534 }
37535 if (!argp2) {
37536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
37537 }
37538 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 (arg1)->OnPaint(*arg2);
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 resultobj = SWIG_Py_Void();
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 int arg2 ;
37556 bool result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 int val2 ;
37560 int ecode2 = 0 ;
37561 PyObject * obj0 = 0 ;
37562 PyObject * obj1 = 0 ;
37563 char * kwnames[] = {
37564 (char *) "self",(char *) "orient", NULL
37565 };
37566
37567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37569 if (!SWIG_IsOK(res1)) {
37570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37571 }
37572 arg1 = reinterpret_cast< wxWindow * >(argp1);
37573 ecode2 = SWIG_AsVal_int(obj1, &val2);
37574 if (!SWIG_IsOK(ecode2)) {
37575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37576 }
37577 arg2 = static_cast< int >(val2);
37578 {
37579 PyThreadState* __tstate = wxPyBeginAllowThreads();
37580 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37581 wxPyEndAllowThreads(__tstate);
37582 if (PyErr_Occurred()) SWIG_fail;
37583 }
37584 {
37585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37586 }
37587 return resultobj;
37588 fail:
37589 return NULL;
37590 }
37591
37592
37593 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37594 PyObject *resultobj = 0;
37595 wxWindow *arg1 = (wxWindow *) 0 ;
37596 int arg2 ;
37597 int arg3 ;
37598 int arg4 ;
37599 int arg5 ;
37600 bool arg6 = (bool) true ;
37601 void *argp1 = 0 ;
37602 int res1 = 0 ;
37603 int val2 ;
37604 int ecode2 = 0 ;
37605 int val3 ;
37606 int ecode3 = 0 ;
37607 int val4 ;
37608 int ecode4 = 0 ;
37609 int val5 ;
37610 int ecode5 = 0 ;
37611 bool val6 ;
37612 int ecode6 = 0 ;
37613 PyObject * obj0 = 0 ;
37614 PyObject * obj1 = 0 ;
37615 PyObject * obj2 = 0 ;
37616 PyObject * obj3 = 0 ;
37617 PyObject * obj4 = 0 ;
37618 PyObject * obj5 = 0 ;
37619 char * kwnames[] = {
37620 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37621 };
37622
37623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37625 if (!SWIG_IsOK(res1)) {
37626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37627 }
37628 arg1 = reinterpret_cast< wxWindow * >(argp1);
37629 ecode2 = SWIG_AsVal_int(obj1, &val2);
37630 if (!SWIG_IsOK(ecode2)) {
37631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37632 }
37633 arg2 = static_cast< int >(val2);
37634 ecode3 = SWIG_AsVal_int(obj2, &val3);
37635 if (!SWIG_IsOK(ecode3)) {
37636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37637 }
37638 arg3 = static_cast< int >(val3);
37639 ecode4 = SWIG_AsVal_int(obj3, &val4);
37640 if (!SWIG_IsOK(ecode4)) {
37641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37642 }
37643 arg4 = static_cast< int >(val4);
37644 ecode5 = SWIG_AsVal_int(obj4, &val5);
37645 if (!SWIG_IsOK(ecode5)) {
37646 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37647 }
37648 arg5 = static_cast< int >(val5);
37649 if (obj5) {
37650 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37651 if (!SWIG_IsOK(ecode6)) {
37652 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37653 }
37654 arg6 = static_cast< bool >(val6);
37655 }
37656 {
37657 PyThreadState* __tstate = wxPyBeginAllowThreads();
37658 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37659 wxPyEndAllowThreads(__tstate);
37660 if (PyErr_Occurred()) SWIG_fail;
37661 }
37662 resultobj = SWIG_Py_Void();
37663 return resultobj;
37664 fail:
37665 return NULL;
37666 }
37667
37668
37669 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37670 PyObject *resultobj = 0;
37671 wxWindow *arg1 = (wxWindow *) 0 ;
37672 int arg2 ;
37673 int arg3 ;
37674 bool arg4 = (bool) true ;
37675 void *argp1 = 0 ;
37676 int res1 = 0 ;
37677 int val2 ;
37678 int ecode2 = 0 ;
37679 int val3 ;
37680 int ecode3 = 0 ;
37681 bool val4 ;
37682 int ecode4 = 0 ;
37683 PyObject * obj0 = 0 ;
37684 PyObject * obj1 = 0 ;
37685 PyObject * obj2 = 0 ;
37686 PyObject * obj3 = 0 ;
37687 char * kwnames[] = {
37688 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37689 };
37690
37691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37693 if (!SWIG_IsOK(res1)) {
37694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37695 }
37696 arg1 = reinterpret_cast< wxWindow * >(argp1);
37697 ecode2 = SWIG_AsVal_int(obj1, &val2);
37698 if (!SWIG_IsOK(ecode2)) {
37699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37700 }
37701 arg2 = static_cast< int >(val2);
37702 ecode3 = SWIG_AsVal_int(obj2, &val3);
37703 if (!SWIG_IsOK(ecode3)) {
37704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37705 }
37706 arg3 = static_cast< int >(val3);
37707 if (obj3) {
37708 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37709 if (!SWIG_IsOK(ecode4)) {
37710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37711 }
37712 arg4 = static_cast< bool >(val4);
37713 }
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 (arg1)->SetScrollPos(arg2,arg3,arg4);
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 resultobj = SWIG_Py_Void();
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj = 0;
37729 wxWindow *arg1 = (wxWindow *) 0 ;
37730 int arg2 ;
37731 int result;
37732 void *argp1 = 0 ;
37733 int res1 = 0 ;
37734 int val2 ;
37735 int ecode2 = 0 ;
37736 PyObject * obj0 = 0 ;
37737 PyObject * obj1 = 0 ;
37738 char * kwnames[] = {
37739 (char *) "self",(char *) "orientation", NULL
37740 };
37741
37742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37744 if (!SWIG_IsOK(res1)) {
37745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37746 }
37747 arg1 = reinterpret_cast< wxWindow * >(argp1);
37748 ecode2 = SWIG_AsVal_int(obj1, &val2);
37749 if (!SWIG_IsOK(ecode2)) {
37750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37751 }
37752 arg2 = static_cast< int >(val2);
37753 {
37754 PyThreadState* __tstate = wxPyBeginAllowThreads();
37755 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 resultobj = SWIG_From_int(static_cast< int >(result));
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj = 0;
37768 wxWindow *arg1 = (wxWindow *) 0 ;
37769 int arg2 ;
37770 int result;
37771 void *argp1 = 0 ;
37772 int res1 = 0 ;
37773 int val2 ;
37774 int ecode2 = 0 ;
37775 PyObject * obj0 = 0 ;
37776 PyObject * obj1 = 0 ;
37777 char * kwnames[] = {
37778 (char *) "self",(char *) "orientation", NULL
37779 };
37780
37781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37783 if (!SWIG_IsOK(res1)) {
37784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37785 }
37786 arg1 = reinterpret_cast< wxWindow * >(argp1);
37787 ecode2 = SWIG_AsVal_int(obj1, &val2);
37788 if (!SWIG_IsOK(ecode2)) {
37789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37790 }
37791 arg2 = static_cast< int >(val2);
37792 {
37793 PyThreadState* __tstate = wxPyBeginAllowThreads();
37794 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 resultobj = SWIG_From_int(static_cast< int >(result));
37799 return resultobj;
37800 fail:
37801 return NULL;
37802 }
37803
37804
37805 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37806 PyObject *resultobj = 0;
37807 wxWindow *arg1 = (wxWindow *) 0 ;
37808 int arg2 ;
37809 int result;
37810 void *argp1 = 0 ;
37811 int res1 = 0 ;
37812 int val2 ;
37813 int ecode2 = 0 ;
37814 PyObject * obj0 = 0 ;
37815 PyObject * obj1 = 0 ;
37816 char * kwnames[] = {
37817 (char *) "self",(char *) "orientation", NULL
37818 };
37819
37820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37822 if (!SWIG_IsOK(res1)) {
37823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37824 }
37825 arg1 = reinterpret_cast< wxWindow * >(argp1);
37826 ecode2 = SWIG_AsVal_int(obj1, &val2);
37827 if (!SWIG_IsOK(ecode2)) {
37828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37829 }
37830 arg2 = static_cast< int >(val2);
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37834 wxPyEndAllowThreads(__tstate);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 }
37837 resultobj = SWIG_From_int(static_cast< int >(result));
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37845 PyObject *resultobj = 0;
37846 wxWindow *arg1 = (wxWindow *) 0 ;
37847 int arg2 ;
37848 int arg3 ;
37849 wxRect *arg4 = (wxRect *) NULL ;
37850 void *argp1 = 0 ;
37851 int res1 = 0 ;
37852 int val2 ;
37853 int ecode2 = 0 ;
37854 int val3 ;
37855 int ecode3 = 0 ;
37856 void *argp4 = 0 ;
37857 int res4 = 0 ;
37858 PyObject * obj0 = 0 ;
37859 PyObject * obj1 = 0 ;
37860 PyObject * obj2 = 0 ;
37861 PyObject * obj3 = 0 ;
37862 char * kwnames[] = {
37863 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37864 };
37865
37866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37868 if (!SWIG_IsOK(res1)) {
37869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37870 }
37871 arg1 = reinterpret_cast< wxWindow * >(argp1);
37872 ecode2 = SWIG_AsVal_int(obj1, &val2);
37873 if (!SWIG_IsOK(ecode2)) {
37874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37875 }
37876 arg2 = static_cast< int >(val2);
37877 ecode3 = SWIG_AsVal_int(obj2, &val3);
37878 if (!SWIG_IsOK(ecode3)) {
37879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37880 }
37881 arg3 = static_cast< int >(val3);
37882 if (obj3) {
37883 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37884 if (!SWIG_IsOK(res4)) {
37885 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37886 }
37887 arg4 = reinterpret_cast< wxRect * >(argp4);
37888 }
37889 {
37890 PyThreadState* __tstate = wxPyBeginAllowThreads();
37891 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37892 wxPyEndAllowThreads(__tstate);
37893 if (PyErr_Occurred()) SWIG_fail;
37894 }
37895 resultobj = SWIG_Py_Void();
37896 return resultobj;
37897 fail:
37898 return NULL;
37899 }
37900
37901
37902 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37903 PyObject *resultobj = 0;
37904 wxWindow *arg1 = (wxWindow *) 0 ;
37905 int arg2 ;
37906 bool result;
37907 void *argp1 = 0 ;
37908 int res1 = 0 ;
37909 int val2 ;
37910 int ecode2 = 0 ;
37911 PyObject * obj0 = 0 ;
37912 PyObject * obj1 = 0 ;
37913 char * kwnames[] = {
37914 (char *) "self",(char *) "lines", NULL
37915 };
37916
37917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37921 }
37922 arg1 = reinterpret_cast< wxWindow * >(argp1);
37923 ecode2 = SWIG_AsVal_int(obj1, &val2);
37924 if (!SWIG_IsOK(ecode2)) {
37925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37926 }
37927 arg2 = static_cast< int >(val2);
37928 {
37929 PyThreadState* __tstate = wxPyBeginAllowThreads();
37930 result = (bool)(arg1)->ScrollLines(arg2);
37931 wxPyEndAllowThreads(__tstate);
37932 if (PyErr_Occurred()) SWIG_fail;
37933 }
37934 {
37935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37936 }
37937 return resultobj;
37938 fail:
37939 return NULL;
37940 }
37941
37942
37943 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37944 PyObject *resultobj = 0;
37945 wxWindow *arg1 = (wxWindow *) 0 ;
37946 int arg2 ;
37947 bool result;
37948 void *argp1 = 0 ;
37949 int res1 = 0 ;
37950 int val2 ;
37951 int ecode2 = 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 char * kwnames[] = {
37955 (char *) "self",(char *) "pages", NULL
37956 };
37957
37958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37960 if (!SWIG_IsOK(res1)) {
37961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37962 }
37963 arg1 = reinterpret_cast< wxWindow * >(argp1);
37964 ecode2 = SWIG_AsVal_int(obj1, &val2);
37965 if (!SWIG_IsOK(ecode2)) {
37966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37967 }
37968 arg2 = static_cast< int >(val2);
37969 {
37970 PyThreadState* __tstate = wxPyBeginAllowThreads();
37971 result = (bool)(arg1)->ScrollPages(arg2);
37972 wxPyEndAllowThreads(__tstate);
37973 if (PyErr_Occurred()) SWIG_fail;
37974 }
37975 {
37976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37977 }
37978 return resultobj;
37979 fail:
37980 return NULL;
37981 }
37982
37983
37984 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37985 PyObject *resultobj = 0;
37986 wxWindow *arg1 = (wxWindow *) 0 ;
37987 bool result;
37988 void *argp1 = 0 ;
37989 int res1 = 0 ;
37990 PyObject *swig_obj[1] ;
37991
37992 if (!args) SWIG_fail;
37993 swig_obj[0] = args;
37994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37995 if (!SWIG_IsOK(res1)) {
37996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37997 }
37998 arg1 = reinterpret_cast< wxWindow * >(argp1);
37999 {
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (bool)(arg1)->LineUp();
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 {
38006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38007 }
38008 return resultobj;
38009 fail:
38010 return NULL;
38011 }
38012
38013
38014 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38015 PyObject *resultobj = 0;
38016 wxWindow *arg1 = (wxWindow *) 0 ;
38017 bool result;
38018 void *argp1 = 0 ;
38019 int res1 = 0 ;
38020 PyObject *swig_obj[1] ;
38021
38022 if (!args) SWIG_fail;
38023 swig_obj[0] = args;
38024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38025 if (!SWIG_IsOK(res1)) {
38026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38027 }
38028 arg1 = reinterpret_cast< wxWindow * >(argp1);
38029 {
38030 PyThreadState* __tstate = wxPyBeginAllowThreads();
38031 result = (bool)(arg1)->LineDown();
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 {
38036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38037 }
38038 return resultobj;
38039 fail:
38040 return NULL;
38041 }
38042
38043
38044 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38045 PyObject *resultobj = 0;
38046 wxWindow *arg1 = (wxWindow *) 0 ;
38047 bool result;
38048 void *argp1 = 0 ;
38049 int res1 = 0 ;
38050 PyObject *swig_obj[1] ;
38051
38052 if (!args) SWIG_fail;
38053 swig_obj[0] = args;
38054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38055 if (!SWIG_IsOK(res1)) {
38056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38057 }
38058 arg1 = reinterpret_cast< wxWindow * >(argp1);
38059 {
38060 PyThreadState* __tstate = wxPyBeginAllowThreads();
38061 result = (bool)(arg1)->PageUp();
38062 wxPyEndAllowThreads(__tstate);
38063 if (PyErr_Occurred()) SWIG_fail;
38064 }
38065 {
38066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38067 }
38068 return resultobj;
38069 fail:
38070 return NULL;
38071 }
38072
38073
38074 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38075 PyObject *resultobj = 0;
38076 wxWindow *arg1 = (wxWindow *) 0 ;
38077 bool result;
38078 void *argp1 = 0 ;
38079 int res1 = 0 ;
38080 PyObject *swig_obj[1] ;
38081
38082 if (!args) SWIG_fail;
38083 swig_obj[0] = args;
38084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38085 if (!SWIG_IsOK(res1)) {
38086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38087 }
38088 arg1 = reinterpret_cast< wxWindow * >(argp1);
38089 {
38090 PyThreadState* __tstate = wxPyBeginAllowThreads();
38091 result = (bool)(arg1)->PageDown();
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 {
38096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38097 }
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj = 0;
38106 wxWindow *arg1 = (wxWindow *) 0 ;
38107 wxString *arg2 = 0 ;
38108 void *argp1 = 0 ;
38109 int res1 = 0 ;
38110 bool temp2 = false ;
38111 PyObject * obj0 = 0 ;
38112 PyObject * obj1 = 0 ;
38113 char * kwnames[] = {
38114 (char *) "self",(char *) "text", NULL
38115 };
38116
38117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38119 if (!SWIG_IsOK(res1)) {
38120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38121 }
38122 arg1 = reinterpret_cast< wxWindow * >(argp1);
38123 {
38124 arg2 = wxString_in_helper(obj1);
38125 if (arg2 == NULL) SWIG_fail;
38126 temp2 = true;
38127 }
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 (arg1)->SetHelpText((wxString const &)*arg2);
38131 wxPyEndAllowThreads(__tstate);
38132 if (PyErr_Occurred()) SWIG_fail;
38133 }
38134 resultobj = SWIG_Py_Void();
38135 {
38136 if (temp2)
38137 delete arg2;
38138 }
38139 return resultobj;
38140 fail:
38141 {
38142 if (temp2)
38143 delete arg2;
38144 }
38145 return NULL;
38146 }
38147
38148
38149 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38150 PyObject *resultobj = 0;
38151 wxWindow *arg1 = (wxWindow *) 0 ;
38152 wxString *arg2 = 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 bool temp2 = false ;
38156 PyObject * obj0 = 0 ;
38157 PyObject * obj1 = 0 ;
38158 char * kwnames[] = {
38159 (char *) "self",(char *) "text", NULL
38160 };
38161
38162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38164 if (!SWIG_IsOK(res1)) {
38165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38166 }
38167 arg1 = reinterpret_cast< wxWindow * >(argp1);
38168 {
38169 arg2 = wxString_in_helper(obj1);
38170 if (arg2 == NULL) SWIG_fail;
38171 temp2 = true;
38172 }
38173 {
38174 PyThreadState* __tstate = wxPyBeginAllowThreads();
38175 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38176 wxPyEndAllowThreads(__tstate);
38177 if (PyErr_Occurred()) SWIG_fail;
38178 }
38179 resultobj = SWIG_Py_Void();
38180 {
38181 if (temp2)
38182 delete arg2;
38183 }
38184 return resultobj;
38185 fail:
38186 {
38187 if (temp2)
38188 delete arg2;
38189 }
38190 return NULL;
38191 }
38192
38193
38194 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj = 0;
38196 wxWindow *arg1 = (wxWindow *) 0 ;
38197 wxPoint *arg2 = 0 ;
38198 wxHelpEvent::Origin arg3 ;
38199 wxString result;
38200 void *argp1 = 0 ;
38201 int res1 = 0 ;
38202 wxPoint temp2 ;
38203 void *argp3 ;
38204 int res3 = 0 ;
38205 PyObject * obj0 = 0 ;
38206 PyObject * obj1 = 0 ;
38207 PyObject * obj2 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "pt",(char *) "origin", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 arg2 = &temp2;
38220 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38221 }
38222 {
38223 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38224 if (!SWIG_IsOK(res3)) {
38225 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38226 }
38227 if (!argp3) {
38228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38229 } else {
38230 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38231 arg3 = *temp;
38232 if (SWIG_IsNewObj(res3)) delete temp;
38233 }
38234 }
38235 {
38236 PyThreadState* __tstate = wxPyBeginAllowThreads();
38237 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38238 wxPyEndAllowThreads(__tstate);
38239 if (PyErr_Occurred()) SWIG_fail;
38240 }
38241 {
38242 #if wxUSE_UNICODE
38243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38244 #else
38245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38246 #endif
38247 }
38248 return resultobj;
38249 fail:
38250 return NULL;
38251 }
38252
38253
38254 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38255 PyObject *resultobj = 0;
38256 wxWindow *arg1 = (wxWindow *) 0 ;
38257 wxString result;
38258 void *argp1 = 0 ;
38259 int res1 = 0 ;
38260 PyObject *swig_obj[1] ;
38261
38262 if (!args) SWIG_fail;
38263 swig_obj[0] = args;
38264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38265 if (!SWIG_IsOK(res1)) {
38266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38267 }
38268 arg1 = reinterpret_cast< wxWindow * >(argp1);
38269 {
38270 PyThreadState* __tstate = wxPyBeginAllowThreads();
38271 result = ((wxWindow const *)arg1)->GetHelpText();
38272 wxPyEndAllowThreads(__tstate);
38273 if (PyErr_Occurred()) SWIG_fail;
38274 }
38275 {
38276 #if wxUSE_UNICODE
38277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38278 #else
38279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38280 #endif
38281 }
38282 return resultobj;
38283 fail:
38284 return NULL;
38285 }
38286
38287
38288 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38289 PyObject *resultobj = 0;
38290 wxWindow *arg1 = (wxWindow *) 0 ;
38291 wxString *arg2 = 0 ;
38292 void *argp1 = 0 ;
38293 int res1 = 0 ;
38294 bool temp2 = false ;
38295 PyObject * obj0 = 0 ;
38296 PyObject * obj1 = 0 ;
38297 char * kwnames[] = {
38298 (char *) "self",(char *) "tip", NULL
38299 };
38300
38301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38303 if (!SWIG_IsOK(res1)) {
38304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38305 }
38306 arg1 = reinterpret_cast< wxWindow * >(argp1);
38307 {
38308 arg2 = wxString_in_helper(obj1);
38309 if (arg2 == NULL) SWIG_fail;
38310 temp2 = true;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 (arg1)->SetToolTip((wxString const &)*arg2);
38315 wxPyEndAllowThreads(__tstate);
38316 if (PyErr_Occurred()) SWIG_fail;
38317 }
38318 resultobj = SWIG_Py_Void();
38319 {
38320 if (temp2)
38321 delete arg2;
38322 }
38323 return resultobj;
38324 fail:
38325 {
38326 if (temp2)
38327 delete arg2;
38328 }
38329 return NULL;
38330 }
38331
38332
38333 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38334 PyObject *resultobj = 0;
38335 wxWindow *arg1 = (wxWindow *) 0 ;
38336 wxToolTip *arg2 = (wxToolTip *) 0 ;
38337 void *argp1 = 0 ;
38338 int res1 = 0 ;
38339 int res2 = 0 ;
38340 PyObject * obj0 = 0 ;
38341 PyObject * obj1 = 0 ;
38342 char * kwnames[] = {
38343 (char *) "self",(char *) "tip", NULL
38344 };
38345
38346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38348 if (!SWIG_IsOK(res1)) {
38349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38350 }
38351 arg1 = reinterpret_cast< wxWindow * >(argp1);
38352 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38353 if (!SWIG_IsOK(res2)) {
38354 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38355 }
38356 {
38357 PyThreadState* __tstate = wxPyBeginAllowThreads();
38358 (arg1)->SetToolTip(arg2);
38359 wxPyEndAllowThreads(__tstate);
38360 if (PyErr_Occurred()) SWIG_fail;
38361 }
38362 resultobj = SWIG_Py_Void();
38363 return resultobj;
38364 fail:
38365 return NULL;
38366 }
38367
38368
38369 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38370 PyObject *resultobj = 0;
38371 wxWindow *arg1 = (wxWindow *) 0 ;
38372 wxToolTip *result = 0 ;
38373 void *argp1 = 0 ;
38374 int res1 = 0 ;
38375 PyObject *swig_obj[1] ;
38376
38377 if (!args) SWIG_fail;
38378 swig_obj[0] = args;
38379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38380 if (!SWIG_IsOK(res1)) {
38381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38382 }
38383 arg1 = reinterpret_cast< wxWindow * >(argp1);
38384 {
38385 PyThreadState* __tstate = wxPyBeginAllowThreads();
38386 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38387 wxPyEndAllowThreads(__tstate);
38388 if (PyErr_Occurred()) SWIG_fail;
38389 }
38390 {
38391 resultobj = wxPyMake_wxObject(result, (bool)0);
38392 }
38393 return resultobj;
38394 fail:
38395 return NULL;
38396 }
38397
38398
38399 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38400 PyObject *resultobj = 0;
38401 wxWindow *arg1 = (wxWindow *) 0 ;
38402 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38403 void *argp1 = 0 ;
38404 int res1 = 0 ;
38405 int res2 = 0 ;
38406 PyObject * obj0 = 0 ;
38407 PyObject * obj1 = 0 ;
38408 char * kwnames[] = {
38409 (char *) "self",(char *) "dropTarget", NULL
38410 };
38411
38412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38414 if (!SWIG_IsOK(res1)) {
38415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38416 }
38417 arg1 = reinterpret_cast< wxWindow * >(argp1);
38418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38419 if (!SWIG_IsOK(res2)) {
38420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38421 }
38422 {
38423 PyThreadState* __tstate = wxPyBeginAllowThreads();
38424 (arg1)->SetDropTarget(arg2);
38425 wxPyEndAllowThreads(__tstate);
38426 if (PyErr_Occurred()) SWIG_fail;
38427 }
38428 resultobj = SWIG_Py_Void();
38429 return resultobj;
38430 fail:
38431 return NULL;
38432 }
38433
38434
38435 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38436 PyObject *resultobj = 0;
38437 wxWindow *arg1 = (wxWindow *) 0 ;
38438 wxPyDropTarget *result = 0 ;
38439 void *argp1 = 0 ;
38440 int res1 = 0 ;
38441 PyObject *swig_obj[1] ;
38442
38443 if (!args) SWIG_fail;
38444 swig_obj[0] = args;
38445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38446 if (!SWIG_IsOK(res1)) {
38447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38448 }
38449 arg1 = reinterpret_cast< wxWindow * >(argp1);
38450 {
38451 PyThreadState* __tstate = wxPyBeginAllowThreads();
38452 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38453 wxPyEndAllowThreads(__tstate);
38454 if (PyErr_Occurred()) SWIG_fail;
38455 }
38456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38457 return resultobj;
38458 fail:
38459 return NULL;
38460 }
38461
38462
38463 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38464 PyObject *resultobj = 0;
38465 wxWindow *arg1 = (wxWindow *) 0 ;
38466 bool arg2 ;
38467 void *argp1 = 0 ;
38468 int res1 = 0 ;
38469 bool val2 ;
38470 int ecode2 = 0 ;
38471 PyObject * obj0 = 0 ;
38472 PyObject * obj1 = 0 ;
38473 char * kwnames[] = {
38474 (char *) "self",(char *) "accept", NULL
38475 };
38476
38477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38479 if (!SWIG_IsOK(res1)) {
38480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38481 }
38482 arg1 = reinterpret_cast< wxWindow * >(argp1);
38483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38484 if (!SWIG_IsOK(ecode2)) {
38485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38486 }
38487 arg2 = static_cast< bool >(val2);
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 (arg1)->DragAcceptFiles(arg2);
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 resultobj = SWIG_Py_Void();
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj = 0;
38503 wxWindow *arg1 = (wxWindow *) 0 ;
38504 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38505 void *argp1 = 0 ;
38506 int res1 = 0 ;
38507 int res2 = 0 ;
38508 PyObject * obj0 = 0 ;
38509 PyObject * obj1 = 0 ;
38510 char * kwnames[] = {
38511 (char *) "self",(char *) "constraints", NULL
38512 };
38513
38514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38516 if (!SWIG_IsOK(res1)) {
38517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38518 }
38519 arg1 = reinterpret_cast< wxWindow * >(argp1);
38520 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38521 if (!SWIG_IsOK(res2)) {
38522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38523 }
38524 {
38525 PyThreadState* __tstate = wxPyBeginAllowThreads();
38526 (arg1)->SetConstraints(arg2);
38527 wxPyEndAllowThreads(__tstate);
38528 if (PyErr_Occurred()) SWIG_fail;
38529 }
38530 resultobj = SWIG_Py_Void();
38531 return resultobj;
38532 fail:
38533 return NULL;
38534 }
38535
38536
38537 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38538 PyObject *resultobj = 0;
38539 wxWindow *arg1 = (wxWindow *) 0 ;
38540 wxLayoutConstraints *result = 0 ;
38541 void *argp1 = 0 ;
38542 int res1 = 0 ;
38543 PyObject *swig_obj[1] ;
38544
38545 if (!args) SWIG_fail;
38546 swig_obj[0] = args;
38547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38548 if (!SWIG_IsOK(res1)) {
38549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38550 }
38551 arg1 = reinterpret_cast< wxWindow * >(argp1);
38552 {
38553 PyThreadState* __tstate = wxPyBeginAllowThreads();
38554 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38555 wxPyEndAllowThreads(__tstate);
38556 if (PyErr_Occurred()) SWIG_fail;
38557 }
38558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38559 return resultobj;
38560 fail:
38561 return NULL;
38562 }
38563
38564
38565 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38566 PyObject *resultobj = 0;
38567 wxWindow *arg1 = (wxWindow *) 0 ;
38568 bool arg2 ;
38569 void *argp1 = 0 ;
38570 int res1 = 0 ;
38571 bool val2 ;
38572 int ecode2 = 0 ;
38573 PyObject * obj0 = 0 ;
38574 PyObject * obj1 = 0 ;
38575 char * kwnames[] = {
38576 (char *) "self",(char *) "autoLayout", NULL
38577 };
38578
38579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38581 if (!SWIG_IsOK(res1)) {
38582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38583 }
38584 arg1 = reinterpret_cast< wxWindow * >(argp1);
38585 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38586 if (!SWIG_IsOK(ecode2)) {
38587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38588 }
38589 arg2 = static_cast< bool >(val2);
38590 {
38591 PyThreadState* __tstate = wxPyBeginAllowThreads();
38592 (arg1)->SetAutoLayout(arg2);
38593 wxPyEndAllowThreads(__tstate);
38594 if (PyErr_Occurred()) SWIG_fail;
38595 }
38596 resultobj = SWIG_Py_Void();
38597 return resultobj;
38598 fail:
38599 return NULL;
38600 }
38601
38602
38603 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38604 PyObject *resultobj = 0;
38605 wxWindow *arg1 = (wxWindow *) 0 ;
38606 bool result;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 PyObject *swig_obj[1] ;
38610
38611 if (!args) SWIG_fail;
38612 swig_obj[0] = args;
38613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 {
38625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38626 }
38627 return resultobj;
38628 fail:
38629 return NULL;
38630 }
38631
38632
38633 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38634 PyObject *resultobj = 0;
38635 wxWindow *arg1 = (wxWindow *) 0 ;
38636 bool result;
38637 void *argp1 = 0 ;
38638 int res1 = 0 ;
38639 PyObject *swig_obj[1] ;
38640
38641 if (!args) SWIG_fail;
38642 swig_obj[0] = args;
38643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38646 }
38647 arg1 = reinterpret_cast< wxWindow * >(argp1);
38648 {
38649 PyThreadState* __tstate = wxPyBeginAllowThreads();
38650 result = (bool)(arg1)->Layout();
38651 wxPyEndAllowThreads(__tstate);
38652 if (PyErr_Occurred()) SWIG_fail;
38653 }
38654 {
38655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38656 }
38657 return resultobj;
38658 fail:
38659 return NULL;
38660 }
38661
38662
38663 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38664 PyObject *resultobj = 0;
38665 wxWindow *arg1 = (wxWindow *) 0 ;
38666 wxSizer *arg2 = (wxSizer *) 0 ;
38667 bool arg3 = (bool) true ;
38668 void *argp1 = 0 ;
38669 int res1 = 0 ;
38670 int res2 = 0 ;
38671 bool val3 ;
38672 int ecode3 = 0 ;
38673 PyObject * obj0 = 0 ;
38674 PyObject * obj1 = 0 ;
38675 PyObject * obj2 = 0 ;
38676 char * kwnames[] = {
38677 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38678 };
38679
38680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38682 if (!SWIG_IsOK(res1)) {
38683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38684 }
38685 arg1 = reinterpret_cast< wxWindow * >(argp1);
38686 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38687 if (!SWIG_IsOK(res2)) {
38688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38689 }
38690 if (obj2) {
38691 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38692 if (!SWIG_IsOK(ecode3)) {
38693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38694 }
38695 arg3 = static_cast< bool >(val3);
38696 }
38697 {
38698 PyThreadState* __tstate = wxPyBeginAllowThreads();
38699 (arg1)->SetSizer(arg2,arg3);
38700 wxPyEndAllowThreads(__tstate);
38701 if (PyErr_Occurred()) SWIG_fail;
38702 }
38703 resultobj = SWIG_Py_Void();
38704 return resultobj;
38705 fail:
38706 return NULL;
38707 }
38708
38709
38710 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38711 PyObject *resultobj = 0;
38712 wxWindow *arg1 = (wxWindow *) 0 ;
38713 wxSizer *arg2 = (wxSizer *) 0 ;
38714 bool arg3 = (bool) true ;
38715 void *argp1 = 0 ;
38716 int res1 = 0 ;
38717 int res2 = 0 ;
38718 bool val3 ;
38719 int ecode3 = 0 ;
38720 PyObject * obj0 = 0 ;
38721 PyObject * obj1 = 0 ;
38722 PyObject * obj2 = 0 ;
38723 char * kwnames[] = {
38724 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38725 };
38726
38727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38729 if (!SWIG_IsOK(res1)) {
38730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38731 }
38732 arg1 = reinterpret_cast< wxWindow * >(argp1);
38733 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38734 if (!SWIG_IsOK(res2)) {
38735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38736 }
38737 if (obj2) {
38738 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38739 if (!SWIG_IsOK(ecode3)) {
38740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38741 }
38742 arg3 = static_cast< bool >(val3);
38743 }
38744 {
38745 PyThreadState* __tstate = wxPyBeginAllowThreads();
38746 (arg1)->SetSizerAndFit(arg2,arg3);
38747 wxPyEndAllowThreads(__tstate);
38748 if (PyErr_Occurred()) SWIG_fail;
38749 }
38750 resultobj = SWIG_Py_Void();
38751 return resultobj;
38752 fail:
38753 return NULL;
38754 }
38755
38756
38757 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38758 PyObject *resultobj = 0;
38759 wxWindow *arg1 = (wxWindow *) 0 ;
38760 wxSizer *result = 0 ;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 PyObject *swig_obj[1] ;
38764
38765 if (!args) SWIG_fail;
38766 swig_obj[0] = args;
38767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38768 if (!SWIG_IsOK(res1)) {
38769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38770 }
38771 arg1 = reinterpret_cast< wxWindow * >(argp1);
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38775 wxPyEndAllowThreads(__tstate);
38776 if (PyErr_Occurred()) SWIG_fail;
38777 }
38778 {
38779 resultobj = wxPyMake_wxObject(result, (bool)0);
38780 }
38781 return resultobj;
38782 fail:
38783 return NULL;
38784 }
38785
38786
38787 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38788 PyObject *resultobj = 0;
38789 wxWindow *arg1 = (wxWindow *) 0 ;
38790 wxSizer *arg2 = (wxSizer *) 0 ;
38791 void *argp1 = 0 ;
38792 int res1 = 0 ;
38793 void *argp2 = 0 ;
38794 int res2 = 0 ;
38795 PyObject * obj0 = 0 ;
38796 PyObject * obj1 = 0 ;
38797 char * kwnames[] = {
38798 (char *) "self",(char *) "sizer", NULL
38799 };
38800
38801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38803 if (!SWIG_IsOK(res1)) {
38804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38805 }
38806 arg1 = reinterpret_cast< wxWindow * >(argp1);
38807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38808 if (!SWIG_IsOK(res2)) {
38809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38810 }
38811 arg2 = reinterpret_cast< wxSizer * >(argp2);
38812 {
38813 PyThreadState* __tstate = wxPyBeginAllowThreads();
38814 (arg1)->SetContainingSizer(arg2);
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 resultobj = SWIG_Py_Void();
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38826 PyObject *resultobj = 0;
38827 wxWindow *arg1 = (wxWindow *) 0 ;
38828 wxSizer *result = 0 ;
38829 void *argp1 = 0 ;
38830 int res1 = 0 ;
38831 PyObject *swig_obj[1] ;
38832
38833 if (!args) SWIG_fail;
38834 swig_obj[0] = args;
38835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38838 }
38839 arg1 = reinterpret_cast< wxWindow * >(argp1);
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 {
38847 resultobj = wxPyMake_wxObject(result, (bool)0);
38848 }
38849 return resultobj;
38850 fail:
38851 return NULL;
38852 }
38853
38854
38855 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38856 PyObject *resultobj = 0;
38857 wxWindow *arg1 = (wxWindow *) 0 ;
38858 void *argp1 = 0 ;
38859 int res1 = 0 ;
38860 PyObject *swig_obj[1] ;
38861
38862 if (!args) SWIG_fail;
38863 swig_obj[0] = args;
38864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38865 if (!SWIG_IsOK(res1)) {
38866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38867 }
38868 arg1 = reinterpret_cast< wxWindow * >(argp1);
38869 {
38870 PyThreadState* __tstate = wxPyBeginAllowThreads();
38871 (arg1)->InheritAttributes();
38872 wxPyEndAllowThreads(__tstate);
38873 if (PyErr_Occurred()) SWIG_fail;
38874 }
38875 resultobj = SWIG_Py_Void();
38876 return resultobj;
38877 fail:
38878 return NULL;
38879 }
38880
38881
38882 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38883 PyObject *resultobj = 0;
38884 wxWindow *arg1 = (wxWindow *) 0 ;
38885 bool result;
38886 void *argp1 = 0 ;
38887 int res1 = 0 ;
38888 PyObject *swig_obj[1] ;
38889
38890 if (!args) SWIG_fail;
38891 swig_obj[0] = args;
38892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38893 if (!SWIG_IsOK(res1)) {
38894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38895 }
38896 arg1 = reinterpret_cast< wxWindow * >(argp1);
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38900 wxPyEndAllowThreads(__tstate);
38901 if (PyErr_Occurred()) SWIG_fail;
38902 }
38903 {
38904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38905 }
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38913 PyObject *resultobj = 0;
38914 wxWindow *arg1 = (wxWindow *) 0 ;
38915 bool result;
38916 void *argp1 = 0 ;
38917 int res1 = 0 ;
38918 PyObject *swig_obj[1] ;
38919
38920 if (!args) SWIG_fail;
38921 swig_obj[0] = args;
38922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38923 if (!SWIG_IsOK(res1)) {
38924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38925 }
38926 arg1 = reinterpret_cast< wxWindow * >(argp1);
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (bool)(arg1)->CanSetTransparent();
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 {
38934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38935 }
38936 return resultobj;
38937 fail:
38938 return NULL;
38939 }
38940
38941
38942 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38943 PyObject *resultobj = 0;
38944 wxWindow *arg1 = (wxWindow *) 0 ;
38945 byte arg2 ;
38946 bool result;
38947 void *argp1 = 0 ;
38948 int res1 = 0 ;
38949 unsigned char val2 ;
38950 int ecode2 = 0 ;
38951 PyObject * obj0 = 0 ;
38952 PyObject * obj1 = 0 ;
38953 char * kwnames[] = {
38954 (char *) "self",(char *) "alpha", NULL
38955 };
38956
38957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38959 if (!SWIG_IsOK(res1)) {
38960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38961 }
38962 arg1 = reinterpret_cast< wxWindow * >(argp1);
38963 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38964 if (!SWIG_IsOK(ecode2)) {
38965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38966 }
38967 arg2 = static_cast< byte >(val2);
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 result = (bool)(arg1)->SetTransparent(arg2);
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 {
38975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38976 }
38977 return resultobj;
38978 fail:
38979 return NULL;
38980 }
38981
38982
38983 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38984 PyObject *obj;
38985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38986 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38987 return SWIG_Py_Void();
38988 }
38989
38990 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38991 return SWIG_Python_InitShadowInstance(args);
38992 }
38993
38994 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38995 PyObject *resultobj = 0;
38996 long arg1 ;
38997 wxWindow *arg2 = (wxWindow *) NULL ;
38998 wxWindow *result = 0 ;
38999 long val1 ;
39000 int ecode1 = 0 ;
39001 void *argp2 = 0 ;
39002 int res2 = 0 ;
39003 PyObject * obj0 = 0 ;
39004 PyObject * obj1 = 0 ;
39005 char * kwnames[] = {
39006 (char *) "id",(char *) "parent", NULL
39007 };
39008
39009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
39010 ecode1 = SWIG_AsVal_long(obj0, &val1);
39011 if (!SWIG_IsOK(ecode1)) {
39012 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
39013 }
39014 arg1 = static_cast< long >(val1);
39015 if (obj1) {
39016 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39017 if (!SWIG_IsOK(res2)) {
39018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
39019 }
39020 arg2 = reinterpret_cast< wxWindow * >(argp2);
39021 }
39022 {
39023 if (!wxPyCheckForApp()) SWIG_fail;
39024 PyThreadState* __tstate = wxPyBeginAllowThreads();
39025 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
39026 wxPyEndAllowThreads(__tstate);
39027 if (PyErr_Occurred()) SWIG_fail;
39028 }
39029 {
39030 resultobj = wxPyMake_wxObject(result, 0);
39031 }
39032 return resultobj;
39033 fail:
39034 return NULL;
39035 }
39036
39037
39038 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39039 PyObject *resultobj = 0;
39040 wxString *arg1 = 0 ;
39041 wxWindow *arg2 = (wxWindow *) NULL ;
39042 wxWindow *result = 0 ;
39043 bool temp1 = false ;
39044 void *argp2 = 0 ;
39045 int res2 = 0 ;
39046 PyObject * obj0 = 0 ;
39047 PyObject * obj1 = 0 ;
39048 char * kwnames[] = {
39049 (char *) "name",(char *) "parent", NULL
39050 };
39051
39052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39053 {
39054 arg1 = wxString_in_helper(obj0);
39055 if (arg1 == NULL) SWIG_fail;
39056 temp1 = true;
39057 }
39058 if (obj1) {
39059 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39060 if (!SWIG_IsOK(res2)) {
39061 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39062 }
39063 arg2 = reinterpret_cast< wxWindow * >(argp2);
39064 }
39065 {
39066 if (!wxPyCheckForApp()) SWIG_fail;
39067 PyThreadState* __tstate = wxPyBeginAllowThreads();
39068 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39069 wxPyEndAllowThreads(__tstate);
39070 if (PyErr_Occurred()) SWIG_fail;
39071 }
39072 {
39073 resultobj = wxPyMake_wxObject(result, 0);
39074 }
39075 {
39076 if (temp1)
39077 delete arg1;
39078 }
39079 return resultobj;
39080 fail:
39081 {
39082 if (temp1)
39083 delete arg1;
39084 }
39085 return NULL;
39086 }
39087
39088
39089 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39090 PyObject *resultobj = 0;
39091 wxString *arg1 = 0 ;
39092 wxWindow *arg2 = (wxWindow *) NULL ;
39093 wxWindow *result = 0 ;
39094 bool temp1 = false ;
39095 void *argp2 = 0 ;
39096 int res2 = 0 ;
39097 PyObject * obj0 = 0 ;
39098 PyObject * obj1 = 0 ;
39099 char * kwnames[] = {
39100 (char *) "label",(char *) "parent", NULL
39101 };
39102
39103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39104 {
39105 arg1 = wxString_in_helper(obj0);
39106 if (arg1 == NULL) SWIG_fail;
39107 temp1 = true;
39108 }
39109 if (obj1) {
39110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39111 if (!SWIG_IsOK(res2)) {
39112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39113 }
39114 arg2 = reinterpret_cast< wxWindow * >(argp2);
39115 }
39116 {
39117 if (!wxPyCheckForApp()) SWIG_fail;
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 {
39124 resultobj = wxPyMake_wxObject(result, 0);
39125 }
39126 {
39127 if (temp1)
39128 delete arg1;
39129 }
39130 return resultobj;
39131 fail:
39132 {
39133 if (temp1)
39134 delete arg1;
39135 }
39136 return NULL;
39137 }
39138
39139
39140 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39141 PyObject *resultobj = 0;
39142 wxWindow *arg1 = (wxWindow *) 0 ;
39143 unsigned long arg2 ;
39144 wxWindow *result = 0 ;
39145 void *argp1 = 0 ;
39146 int res1 = 0 ;
39147 unsigned long val2 ;
39148 int ecode2 = 0 ;
39149 PyObject * obj0 = 0 ;
39150 PyObject * obj1 = 0 ;
39151 char * kwnames[] = {
39152 (char *) "parent",(char *) "_hWnd", NULL
39153 };
39154
39155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39157 if (!SWIG_IsOK(res1)) {
39158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39159 }
39160 arg1 = reinterpret_cast< wxWindow * >(argp1);
39161 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39162 if (!SWIG_IsOK(ecode2)) {
39163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39164 }
39165 arg2 = static_cast< unsigned long >(val2);
39166 {
39167 PyThreadState* __tstate = wxPyBeginAllowThreads();
39168 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39169 wxPyEndAllowThreads(__tstate);
39170 if (PyErr_Occurred()) SWIG_fail;
39171 }
39172 {
39173 resultobj = wxPyMake_wxObject(result, 0);
39174 }
39175 return resultobj;
39176 fail:
39177 return NULL;
39178 }
39179
39180
39181 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39182 PyObject *resultobj = 0;
39183 PyObject *result = 0 ;
39184
39185 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39186 {
39187 PyThreadState* __tstate = wxPyBeginAllowThreads();
39188 result = (PyObject *)GetTopLevelWindows();
39189 wxPyEndAllowThreads(__tstate);
39190 if (PyErr_Occurred()) SWIG_fail;
39191 }
39192 resultobj = result;
39193 return resultobj;
39194 fail:
39195 return NULL;
39196 }
39197
39198
39199 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39200 PyObject *resultobj = 0;
39201 wxValidator *result = 0 ;
39202
39203 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39204 {
39205 PyThreadState* __tstate = wxPyBeginAllowThreads();
39206 result = (wxValidator *)new wxValidator();
39207 wxPyEndAllowThreads(__tstate);
39208 if (PyErr_Occurred()) SWIG_fail;
39209 }
39210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39211 return resultobj;
39212 fail:
39213 return NULL;
39214 }
39215
39216
39217 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39218 PyObject *resultobj = 0;
39219 wxValidator *arg1 = (wxValidator *) 0 ;
39220 wxValidator *result = 0 ;
39221 void *argp1 = 0 ;
39222 int res1 = 0 ;
39223 PyObject *swig_obj[1] ;
39224
39225 if (!args) SWIG_fail;
39226 swig_obj[0] = args;
39227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39228 if (!SWIG_IsOK(res1)) {
39229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39230 }
39231 arg1 = reinterpret_cast< wxValidator * >(argp1);
39232 {
39233 PyThreadState* __tstate = wxPyBeginAllowThreads();
39234 result = (wxValidator *)(arg1)->Clone();
39235 wxPyEndAllowThreads(__tstate);
39236 if (PyErr_Occurred()) SWIG_fail;
39237 }
39238 {
39239 resultobj = wxPyMake_wxObject(result, 0);
39240 }
39241 return resultobj;
39242 fail:
39243 return NULL;
39244 }
39245
39246
39247 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39248 PyObject *resultobj = 0;
39249 wxValidator *arg1 = (wxValidator *) 0 ;
39250 wxWindow *arg2 = (wxWindow *) 0 ;
39251 bool result;
39252 void *argp1 = 0 ;
39253 int res1 = 0 ;
39254 void *argp2 = 0 ;
39255 int res2 = 0 ;
39256 PyObject * obj0 = 0 ;
39257 PyObject * obj1 = 0 ;
39258 char * kwnames[] = {
39259 (char *) "self",(char *) "parent", NULL
39260 };
39261
39262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39264 if (!SWIG_IsOK(res1)) {
39265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39266 }
39267 arg1 = reinterpret_cast< wxValidator * >(argp1);
39268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39269 if (!SWIG_IsOK(res2)) {
39270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39271 }
39272 arg2 = reinterpret_cast< wxWindow * >(argp2);
39273 {
39274 PyThreadState* __tstate = wxPyBeginAllowThreads();
39275 result = (bool)(arg1)->Validate(arg2);
39276 wxPyEndAllowThreads(__tstate);
39277 if (PyErr_Occurred()) SWIG_fail;
39278 }
39279 {
39280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39281 }
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39289 PyObject *resultobj = 0;
39290 wxValidator *arg1 = (wxValidator *) 0 ;
39291 bool result;
39292 void *argp1 = 0 ;
39293 int res1 = 0 ;
39294 PyObject *swig_obj[1] ;
39295
39296 if (!args) SWIG_fail;
39297 swig_obj[0] = args;
39298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39299 if (!SWIG_IsOK(res1)) {
39300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39301 }
39302 arg1 = reinterpret_cast< wxValidator * >(argp1);
39303 {
39304 PyThreadState* __tstate = wxPyBeginAllowThreads();
39305 result = (bool)(arg1)->TransferToWindow();
39306 wxPyEndAllowThreads(__tstate);
39307 if (PyErr_Occurred()) SWIG_fail;
39308 }
39309 {
39310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39311 }
39312 return resultobj;
39313 fail:
39314 return NULL;
39315 }
39316
39317
39318 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39319 PyObject *resultobj = 0;
39320 wxValidator *arg1 = (wxValidator *) 0 ;
39321 bool result;
39322 void *argp1 = 0 ;
39323 int res1 = 0 ;
39324 PyObject *swig_obj[1] ;
39325
39326 if (!args) SWIG_fail;
39327 swig_obj[0] = args;
39328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39329 if (!SWIG_IsOK(res1)) {
39330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39331 }
39332 arg1 = reinterpret_cast< wxValidator * >(argp1);
39333 {
39334 PyThreadState* __tstate = wxPyBeginAllowThreads();
39335 result = (bool)(arg1)->TransferFromWindow();
39336 wxPyEndAllowThreads(__tstate);
39337 if (PyErr_Occurred()) SWIG_fail;
39338 }
39339 {
39340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39341 }
39342 return resultobj;
39343 fail:
39344 return NULL;
39345 }
39346
39347
39348 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39349 PyObject *resultobj = 0;
39350 wxValidator *arg1 = (wxValidator *) 0 ;
39351 wxWindow *result = 0 ;
39352 void *argp1 = 0 ;
39353 int res1 = 0 ;
39354 PyObject *swig_obj[1] ;
39355
39356 if (!args) SWIG_fail;
39357 swig_obj[0] = args;
39358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39359 if (!SWIG_IsOK(res1)) {
39360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39361 }
39362 arg1 = reinterpret_cast< wxValidator * >(argp1);
39363 {
39364 PyThreadState* __tstate = wxPyBeginAllowThreads();
39365 result = (wxWindow *)(arg1)->GetWindow();
39366 wxPyEndAllowThreads(__tstate);
39367 if (PyErr_Occurred()) SWIG_fail;
39368 }
39369 {
39370 resultobj = wxPyMake_wxObject(result, 0);
39371 }
39372 return resultobj;
39373 fail:
39374 return NULL;
39375 }
39376
39377
39378 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39379 PyObject *resultobj = 0;
39380 wxValidator *arg1 = (wxValidator *) 0 ;
39381 wxWindow *arg2 = (wxWindow *) 0 ;
39382 void *argp1 = 0 ;
39383 int res1 = 0 ;
39384 void *argp2 = 0 ;
39385 int res2 = 0 ;
39386 PyObject * obj0 = 0 ;
39387 PyObject * obj1 = 0 ;
39388 char * kwnames[] = {
39389 (char *) "self",(char *) "window", NULL
39390 };
39391
39392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39394 if (!SWIG_IsOK(res1)) {
39395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39396 }
39397 arg1 = reinterpret_cast< wxValidator * >(argp1);
39398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39399 if (!SWIG_IsOK(res2)) {
39400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39401 }
39402 arg2 = reinterpret_cast< wxWindow * >(argp2);
39403 {
39404 PyThreadState* __tstate = wxPyBeginAllowThreads();
39405 (arg1)->SetWindow(arg2);
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 resultobj = SWIG_Py_Void();
39410 return resultobj;
39411 fail:
39412 return NULL;
39413 }
39414
39415
39416 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39417 PyObject *resultobj = 0;
39418 bool result;
39419
39420 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39421 {
39422 PyThreadState* __tstate = wxPyBeginAllowThreads();
39423 result = (bool)wxValidator::IsSilent();
39424 wxPyEndAllowThreads(__tstate);
39425 if (PyErr_Occurred()) SWIG_fail;
39426 }
39427 {
39428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39429 }
39430 return resultobj;
39431 fail:
39432 return NULL;
39433 }
39434
39435
39436 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39437 PyObject *resultobj = 0;
39438 int arg1 = (int) true ;
39439 int val1 ;
39440 int ecode1 = 0 ;
39441 PyObject * obj0 = 0 ;
39442 char * kwnames[] = {
39443 (char *) "doIt", NULL
39444 };
39445
39446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39447 if (obj0) {
39448 ecode1 = SWIG_AsVal_int(obj0, &val1);
39449 if (!SWIG_IsOK(ecode1)) {
39450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39451 }
39452 arg1 = static_cast< int >(val1);
39453 }
39454 {
39455 PyThreadState* __tstate = wxPyBeginAllowThreads();
39456 wxValidator::SetBellOnError(arg1);
39457 wxPyEndAllowThreads(__tstate);
39458 if (PyErr_Occurred()) SWIG_fail;
39459 }
39460 resultobj = SWIG_Py_Void();
39461 return resultobj;
39462 fail:
39463 return NULL;
39464 }
39465
39466
39467 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39468 PyObject *obj;
39469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39470 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39471 return SWIG_Py_Void();
39472 }
39473
39474 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39475 return SWIG_Python_InitShadowInstance(args);
39476 }
39477
39478 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39479 PyObject *resultobj = 0;
39480 wxPyValidator *result = 0 ;
39481
39482 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (wxPyValidator *)new wxPyValidator();
39486 wxPyEndAllowThreads(__tstate);
39487 if (PyErr_Occurred()) SWIG_fail;
39488 }
39489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39490 return resultobj;
39491 fail:
39492 return NULL;
39493 }
39494
39495
39496 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39497 PyObject *resultobj = 0;
39498 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39499 PyObject *arg2 = (PyObject *) 0 ;
39500 PyObject *arg3 = (PyObject *) 0 ;
39501 int arg4 = (int) true ;
39502 void *argp1 = 0 ;
39503 int res1 = 0 ;
39504 int val4 ;
39505 int ecode4 = 0 ;
39506 PyObject * obj0 = 0 ;
39507 PyObject * obj1 = 0 ;
39508 PyObject * obj2 = 0 ;
39509 PyObject * obj3 = 0 ;
39510 char * kwnames[] = {
39511 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39512 };
39513
39514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39516 if (!SWIG_IsOK(res1)) {
39517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39518 }
39519 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39520 arg2 = obj1;
39521 arg3 = obj2;
39522 if (obj3) {
39523 ecode4 = SWIG_AsVal_int(obj3, &val4);
39524 if (!SWIG_IsOK(ecode4)) {
39525 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39526 }
39527 arg4 = static_cast< int >(val4);
39528 }
39529 {
39530 PyThreadState* __tstate = wxPyBeginAllowThreads();
39531 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39532 wxPyEndAllowThreads(__tstate);
39533 if (PyErr_Occurred()) SWIG_fail;
39534 }
39535 resultobj = SWIG_Py_Void();
39536 return resultobj;
39537 fail:
39538 return NULL;
39539 }
39540
39541
39542 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39543 PyObject *obj;
39544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39546 return SWIG_Py_Void();
39547 }
39548
39549 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39550 return SWIG_Python_InitShadowInstance(args);
39551 }
39552
39553 SWIGINTERN int DefaultValidator_set(PyObject *) {
39554 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39555 return 1;
39556 }
39557
39558
39559 SWIGINTERN PyObject *DefaultValidator_get(void) {
39560 PyObject *pyobj = 0;
39561
39562 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39563 return pyobj;
39564 }
39565
39566
39567 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj = 0;
39569 wxString const &arg1_defvalue = wxPyEmptyString ;
39570 wxString *arg1 = (wxString *) &arg1_defvalue ;
39571 long arg2 = (long) 0 ;
39572 wxMenu *result = 0 ;
39573 bool temp1 = false ;
39574 long val2 ;
39575 int ecode2 = 0 ;
39576 PyObject * obj0 = 0 ;
39577 PyObject * obj1 = 0 ;
39578 char * kwnames[] = {
39579 (char *) "title",(char *) "style", NULL
39580 };
39581
39582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39583 if (obj0) {
39584 {
39585 arg1 = wxString_in_helper(obj0);
39586 if (arg1 == NULL) SWIG_fail;
39587 temp1 = true;
39588 }
39589 }
39590 if (obj1) {
39591 ecode2 = SWIG_AsVal_long(obj1, &val2);
39592 if (!SWIG_IsOK(ecode2)) {
39593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39594 }
39595 arg2 = static_cast< long >(val2);
39596 }
39597 {
39598 if (!wxPyCheckForApp()) SWIG_fail;
39599 PyThreadState* __tstate = wxPyBeginAllowThreads();
39600 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39601 wxPyEndAllowThreads(__tstate);
39602 if (PyErr_Occurred()) SWIG_fail;
39603 }
39604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39605 {
39606 if (temp1)
39607 delete arg1;
39608 }
39609 return resultobj;
39610 fail:
39611 {
39612 if (temp1)
39613 delete arg1;
39614 }
39615 return NULL;
39616 }
39617
39618
39619 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39620 PyObject *resultobj = 0;
39621 wxMenu *arg1 = (wxMenu *) 0 ;
39622 int arg2 ;
39623 wxString const &arg3_defvalue = wxPyEmptyString ;
39624 wxString *arg3 = (wxString *) &arg3_defvalue ;
39625 wxString const &arg4_defvalue = wxPyEmptyString ;
39626 wxString *arg4 = (wxString *) &arg4_defvalue ;
39627 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39628 wxMenuItem *result = 0 ;
39629 void *argp1 = 0 ;
39630 int res1 = 0 ;
39631 int val2 ;
39632 int ecode2 = 0 ;
39633 bool temp3 = false ;
39634 bool temp4 = false ;
39635 int val5 ;
39636 int ecode5 = 0 ;
39637 PyObject * obj0 = 0 ;
39638 PyObject * obj1 = 0 ;
39639 PyObject * obj2 = 0 ;
39640 PyObject * obj3 = 0 ;
39641 PyObject * obj4 = 0 ;
39642 char * kwnames[] = {
39643 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39644 };
39645
39646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39648 if (!SWIG_IsOK(res1)) {
39649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39650 }
39651 arg1 = reinterpret_cast< wxMenu * >(argp1);
39652 ecode2 = SWIG_AsVal_int(obj1, &val2);
39653 if (!SWIG_IsOK(ecode2)) {
39654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39655 }
39656 arg2 = static_cast< int >(val2);
39657 if (obj2) {
39658 {
39659 arg3 = wxString_in_helper(obj2);
39660 if (arg3 == NULL) SWIG_fail;
39661 temp3 = true;
39662 }
39663 }
39664 if (obj3) {
39665 {
39666 arg4 = wxString_in_helper(obj3);
39667 if (arg4 == NULL) SWIG_fail;
39668 temp4 = true;
39669 }
39670 }
39671 if (obj4) {
39672 ecode5 = SWIG_AsVal_int(obj4, &val5);
39673 if (!SWIG_IsOK(ecode5)) {
39674 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39675 }
39676 arg5 = static_cast< wxItemKind >(val5);
39677 }
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 {
39685 resultobj = wxPyMake_wxObject(result, (bool)0);
39686 }
39687 {
39688 if (temp3)
39689 delete arg3;
39690 }
39691 {
39692 if (temp4)
39693 delete arg4;
39694 }
39695 return resultobj;
39696 fail:
39697 {
39698 if (temp3)
39699 delete arg3;
39700 }
39701 {
39702 if (temp4)
39703 delete arg4;
39704 }
39705 return NULL;
39706 }
39707
39708
39709 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39710 PyObject *resultobj = 0;
39711 wxMenu *arg1 = (wxMenu *) 0 ;
39712 wxMenuItem *result = 0 ;
39713 void *argp1 = 0 ;
39714 int res1 = 0 ;
39715 PyObject *swig_obj[1] ;
39716
39717 if (!args) SWIG_fail;
39718 swig_obj[0] = args;
39719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39720 if (!SWIG_IsOK(res1)) {
39721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39722 }
39723 arg1 = reinterpret_cast< wxMenu * >(argp1);
39724 {
39725 PyThreadState* __tstate = wxPyBeginAllowThreads();
39726 result = (wxMenuItem *)(arg1)->AppendSeparator();
39727 wxPyEndAllowThreads(__tstate);
39728 if (PyErr_Occurred()) SWIG_fail;
39729 }
39730 {
39731 resultobj = wxPyMake_wxObject(result, (bool)0);
39732 }
39733 return resultobj;
39734 fail:
39735 return NULL;
39736 }
39737
39738
39739 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39740 PyObject *resultobj = 0;
39741 wxMenu *arg1 = (wxMenu *) 0 ;
39742 int arg2 ;
39743 wxString *arg3 = 0 ;
39744 wxString const &arg4_defvalue = wxPyEmptyString ;
39745 wxString *arg4 = (wxString *) &arg4_defvalue ;
39746 wxMenuItem *result = 0 ;
39747 void *argp1 = 0 ;
39748 int res1 = 0 ;
39749 int val2 ;
39750 int ecode2 = 0 ;
39751 bool temp3 = false ;
39752 bool temp4 = false ;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 PyObject * obj2 = 0 ;
39756 PyObject * obj3 = 0 ;
39757 char * kwnames[] = {
39758 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39759 };
39760
39761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39763 if (!SWIG_IsOK(res1)) {
39764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39765 }
39766 arg1 = reinterpret_cast< wxMenu * >(argp1);
39767 ecode2 = SWIG_AsVal_int(obj1, &val2);
39768 if (!SWIG_IsOK(ecode2)) {
39769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39770 }
39771 arg2 = static_cast< int >(val2);
39772 {
39773 arg3 = wxString_in_helper(obj2);
39774 if (arg3 == NULL) SWIG_fail;
39775 temp3 = true;
39776 }
39777 if (obj3) {
39778 {
39779 arg4 = wxString_in_helper(obj3);
39780 if (arg4 == NULL) SWIG_fail;
39781 temp4 = true;
39782 }
39783 }
39784 {
39785 PyThreadState* __tstate = wxPyBeginAllowThreads();
39786 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39787 wxPyEndAllowThreads(__tstate);
39788 if (PyErr_Occurred()) SWIG_fail;
39789 }
39790 {
39791 resultobj = wxPyMake_wxObject(result, (bool)0);
39792 }
39793 {
39794 if (temp3)
39795 delete arg3;
39796 }
39797 {
39798 if (temp4)
39799 delete arg4;
39800 }
39801 return resultobj;
39802 fail:
39803 {
39804 if (temp3)
39805 delete arg3;
39806 }
39807 {
39808 if (temp4)
39809 delete arg4;
39810 }
39811 return NULL;
39812 }
39813
39814
39815 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39816 PyObject *resultobj = 0;
39817 wxMenu *arg1 = (wxMenu *) 0 ;
39818 int arg2 ;
39819 wxString *arg3 = 0 ;
39820 wxString const &arg4_defvalue = wxPyEmptyString ;
39821 wxString *arg4 = (wxString *) &arg4_defvalue ;
39822 wxMenuItem *result = 0 ;
39823 void *argp1 = 0 ;
39824 int res1 = 0 ;
39825 int val2 ;
39826 int ecode2 = 0 ;
39827 bool temp3 = false ;
39828 bool temp4 = false ;
39829 PyObject * obj0 = 0 ;
39830 PyObject * obj1 = 0 ;
39831 PyObject * obj2 = 0 ;
39832 PyObject * obj3 = 0 ;
39833 char * kwnames[] = {
39834 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39835 };
39836
39837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39839 if (!SWIG_IsOK(res1)) {
39840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39841 }
39842 arg1 = reinterpret_cast< wxMenu * >(argp1);
39843 ecode2 = SWIG_AsVal_int(obj1, &val2);
39844 if (!SWIG_IsOK(ecode2)) {
39845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39846 }
39847 arg2 = static_cast< int >(val2);
39848 {
39849 arg3 = wxString_in_helper(obj2);
39850 if (arg3 == NULL) SWIG_fail;
39851 temp3 = true;
39852 }
39853 if (obj3) {
39854 {
39855 arg4 = wxString_in_helper(obj3);
39856 if (arg4 == NULL) SWIG_fail;
39857 temp4 = true;
39858 }
39859 }
39860 {
39861 PyThreadState* __tstate = wxPyBeginAllowThreads();
39862 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 {
39867 resultobj = wxPyMake_wxObject(result, (bool)0);
39868 }
39869 {
39870 if (temp3)
39871 delete arg3;
39872 }
39873 {
39874 if (temp4)
39875 delete arg4;
39876 }
39877 return resultobj;
39878 fail:
39879 {
39880 if (temp3)
39881 delete arg3;
39882 }
39883 {
39884 if (temp4)
39885 delete arg4;
39886 }
39887 return NULL;
39888 }
39889
39890
39891 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39892 PyObject *resultobj = 0;
39893 wxMenu *arg1 = (wxMenu *) 0 ;
39894 int arg2 ;
39895 wxString *arg3 = 0 ;
39896 wxMenu *arg4 = (wxMenu *) 0 ;
39897 wxString const &arg5_defvalue = wxPyEmptyString ;
39898 wxString *arg5 = (wxString *) &arg5_defvalue ;
39899 wxMenuItem *result = 0 ;
39900 void *argp1 = 0 ;
39901 int res1 = 0 ;
39902 int val2 ;
39903 int ecode2 = 0 ;
39904 bool temp3 = false ;
39905 void *argp4 = 0 ;
39906 int res4 = 0 ;
39907 bool temp5 = false ;
39908 PyObject * obj0 = 0 ;
39909 PyObject * obj1 = 0 ;
39910 PyObject * obj2 = 0 ;
39911 PyObject * obj3 = 0 ;
39912 PyObject * obj4 = 0 ;
39913 char * kwnames[] = {
39914 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39915 };
39916
39917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39919 if (!SWIG_IsOK(res1)) {
39920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39921 }
39922 arg1 = reinterpret_cast< wxMenu * >(argp1);
39923 ecode2 = SWIG_AsVal_int(obj1, &val2);
39924 if (!SWIG_IsOK(ecode2)) {
39925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39926 }
39927 arg2 = static_cast< int >(val2);
39928 {
39929 arg3 = wxString_in_helper(obj2);
39930 if (arg3 == NULL) SWIG_fail;
39931 temp3 = true;
39932 }
39933 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39934 if (!SWIG_IsOK(res4)) {
39935 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39936 }
39937 arg4 = reinterpret_cast< wxMenu * >(argp4);
39938 if (obj4) {
39939 {
39940 arg5 = wxString_in_helper(obj4);
39941 if (arg5 == NULL) SWIG_fail;
39942 temp5 = true;
39943 }
39944 }
39945 {
39946 PyThreadState* __tstate = wxPyBeginAllowThreads();
39947 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 {
39952 resultobj = wxPyMake_wxObject(result, (bool)0);
39953 }
39954 {
39955 if (temp3)
39956 delete arg3;
39957 }
39958 {
39959 if (temp5)
39960 delete arg5;
39961 }
39962 return resultobj;
39963 fail:
39964 {
39965 if (temp3)
39966 delete arg3;
39967 }
39968 {
39969 if (temp5)
39970 delete arg5;
39971 }
39972 return NULL;
39973 }
39974
39975
39976 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39977 PyObject *resultobj = 0;
39978 wxMenu *arg1 = (wxMenu *) 0 ;
39979 wxMenu *arg2 = (wxMenu *) 0 ;
39980 wxString *arg3 = 0 ;
39981 wxString const &arg4_defvalue = wxPyEmptyString ;
39982 wxString *arg4 = (wxString *) &arg4_defvalue ;
39983 wxMenuItem *result = 0 ;
39984 void *argp1 = 0 ;
39985 int res1 = 0 ;
39986 void *argp2 = 0 ;
39987 int res2 = 0 ;
39988 bool temp3 = false ;
39989 bool temp4 = false ;
39990 PyObject * obj0 = 0 ;
39991 PyObject * obj1 = 0 ;
39992 PyObject * obj2 = 0 ;
39993 PyObject * obj3 = 0 ;
39994 char * kwnames[] = {
39995 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39996 };
39997
39998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40000 if (!SWIG_IsOK(res1)) {
40001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40002 }
40003 arg1 = reinterpret_cast< wxMenu * >(argp1);
40004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40005 if (!SWIG_IsOK(res2)) {
40006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40007 }
40008 arg2 = reinterpret_cast< wxMenu * >(argp2);
40009 {
40010 arg3 = wxString_in_helper(obj2);
40011 if (arg3 == NULL) SWIG_fail;
40012 temp3 = true;
40013 }
40014 if (obj3) {
40015 {
40016 arg4 = wxString_in_helper(obj3);
40017 if (arg4 == NULL) SWIG_fail;
40018 temp4 = true;
40019 }
40020 }
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 {
40028 resultobj = wxPyMake_wxObject(result, (bool)0);
40029 }
40030 {
40031 if (temp3)
40032 delete arg3;
40033 }
40034 {
40035 if (temp4)
40036 delete arg4;
40037 }
40038 return resultobj;
40039 fail:
40040 {
40041 if (temp3)
40042 delete arg3;
40043 }
40044 {
40045 if (temp4)
40046 delete arg4;
40047 }
40048 return NULL;
40049 }
40050
40051
40052 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40053 PyObject *resultobj = 0;
40054 wxMenu *arg1 = (wxMenu *) 0 ;
40055 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40056 wxMenuItem *result = 0 ;
40057 void *argp1 = 0 ;
40058 int res1 = 0 ;
40059 int res2 = 0 ;
40060 PyObject * obj0 = 0 ;
40061 PyObject * obj1 = 0 ;
40062 char * kwnames[] = {
40063 (char *) "self",(char *) "item", NULL
40064 };
40065
40066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40068 if (!SWIG_IsOK(res1)) {
40069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40070 }
40071 arg1 = reinterpret_cast< wxMenu * >(argp1);
40072 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40073 if (!SWIG_IsOK(res2)) {
40074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40075 }
40076 {
40077 PyThreadState* __tstate = wxPyBeginAllowThreads();
40078 result = (wxMenuItem *)(arg1)->Append(arg2);
40079 wxPyEndAllowThreads(__tstate);
40080 if (PyErr_Occurred()) SWIG_fail;
40081 }
40082 {
40083 resultobj = wxPyMake_wxObject(result, (bool)0);
40084 }
40085 return resultobj;
40086 fail:
40087 return NULL;
40088 }
40089
40090
40091 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40092 PyObject *resultobj = 0;
40093 wxMenu *arg1 = (wxMenu *) 0 ;
40094 size_t arg2 ;
40095 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40096 wxMenuItem *result = 0 ;
40097 void *argp1 = 0 ;
40098 int res1 = 0 ;
40099 size_t val2 ;
40100 int ecode2 = 0 ;
40101 int res3 = 0 ;
40102 PyObject * obj0 = 0 ;
40103 PyObject * obj1 = 0 ;
40104 PyObject * obj2 = 0 ;
40105 char * kwnames[] = {
40106 (char *) "self",(char *) "pos",(char *) "item", NULL
40107 };
40108
40109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40111 if (!SWIG_IsOK(res1)) {
40112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40113 }
40114 arg1 = reinterpret_cast< wxMenu * >(argp1);
40115 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40116 if (!SWIG_IsOK(ecode2)) {
40117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40118 }
40119 arg2 = static_cast< size_t >(val2);
40120 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40121 if (!SWIG_IsOK(res3)) {
40122 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40123 }
40124 {
40125 PyThreadState* __tstate = wxPyBeginAllowThreads();
40126 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40127 wxPyEndAllowThreads(__tstate);
40128 if (PyErr_Occurred()) SWIG_fail;
40129 }
40130 {
40131 resultobj = wxPyMake_wxObject(result, (bool)0);
40132 }
40133 return resultobj;
40134 fail:
40135 return NULL;
40136 }
40137
40138
40139 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40140 PyObject *resultobj = 0;
40141 wxMenu *arg1 = (wxMenu *) 0 ;
40142 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40143 wxMenuItem *result = 0 ;
40144 void *argp1 = 0 ;
40145 int res1 = 0 ;
40146 int res2 = 0 ;
40147 PyObject * obj0 = 0 ;
40148 PyObject * obj1 = 0 ;
40149 char * kwnames[] = {
40150 (char *) "self",(char *) "item", NULL
40151 };
40152
40153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40155 if (!SWIG_IsOK(res1)) {
40156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40157 }
40158 arg1 = reinterpret_cast< wxMenu * >(argp1);
40159 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40160 if (!SWIG_IsOK(res2)) {
40161 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40162 }
40163 {
40164 PyThreadState* __tstate = wxPyBeginAllowThreads();
40165 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40166 wxPyEndAllowThreads(__tstate);
40167 if (PyErr_Occurred()) SWIG_fail;
40168 }
40169 {
40170 resultobj = wxPyMake_wxObject(result, (bool)0);
40171 }
40172 return resultobj;
40173 fail:
40174 return NULL;
40175 }
40176
40177
40178 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40179 PyObject *resultobj = 0;
40180 wxMenu *arg1 = (wxMenu *) 0 ;
40181 void *argp1 = 0 ;
40182 int res1 = 0 ;
40183 PyObject *swig_obj[1] ;
40184
40185 if (!args) SWIG_fail;
40186 swig_obj[0] = args;
40187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 {
40193 PyThreadState* __tstate = wxPyBeginAllowThreads();
40194 (arg1)->Break();
40195 wxPyEndAllowThreads(__tstate);
40196 if (PyErr_Occurred()) SWIG_fail;
40197 }
40198 resultobj = SWIG_Py_Void();
40199 return resultobj;
40200 fail:
40201 return NULL;
40202 }
40203
40204
40205 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40206 PyObject *resultobj = 0;
40207 wxMenu *arg1 = (wxMenu *) 0 ;
40208 size_t arg2 ;
40209 int arg3 ;
40210 wxString const &arg4_defvalue = wxPyEmptyString ;
40211 wxString *arg4 = (wxString *) &arg4_defvalue ;
40212 wxString const &arg5_defvalue = wxPyEmptyString ;
40213 wxString *arg5 = (wxString *) &arg5_defvalue ;
40214 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40215 wxMenuItem *result = 0 ;
40216 void *argp1 = 0 ;
40217 int res1 = 0 ;
40218 size_t val2 ;
40219 int ecode2 = 0 ;
40220 int val3 ;
40221 int ecode3 = 0 ;
40222 bool temp4 = false ;
40223 bool temp5 = false ;
40224 int val6 ;
40225 int ecode6 = 0 ;
40226 PyObject * obj0 = 0 ;
40227 PyObject * obj1 = 0 ;
40228 PyObject * obj2 = 0 ;
40229 PyObject * obj3 = 0 ;
40230 PyObject * obj4 = 0 ;
40231 PyObject * obj5 = 0 ;
40232 char * kwnames[] = {
40233 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40234 };
40235
40236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40238 if (!SWIG_IsOK(res1)) {
40239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40240 }
40241 arg1 = reinterpret_cast< wxMenu * >(argp1);
40242 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40243 if (!SWIG_IsOK(ecode2)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40245 }
40246 arg2 = static_cast< size_t >(val2);
40247 ecode3 = SWIG_AsVal_int(obj2, &val3);
40248 if (!SWIG_IsOK(ecode3)) {
40249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40250 }
40251 arg3 = static_cast< int >(val3);
40252 if (obj3) {
40253 {
40254 arg4 = wxString_in_helper(obj3);
40255 if (arg4 == NULL) SWIG_fail;
40256 temp4 = true;
40257 }
40258 }
40259 if (obj4) {
40260 {
40261 arg5 = wxString_in_helper(obj4);
40262 if (arg5 == NULL) SWIG_fail;
40263 temp5 = true;
40264 }
40265 }
40266 if (obj5) {
40267 ecode6 = SWIG_AsVal_int(obj5, &val6);
40268 if (!SWIG_IsOK(ecode6)) {
40269 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40270 }
40271 arg6 = static_cast< wxItemKind >(val6);
40272 }
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40276 wxPyEndAllowThreads(__tstate);
40277 if (PyErr_Occurred()) SWIG_fail;
40278 }
40279 {
40280 resultobj = wxPyMake_wxObject(result, (bool)0);
40281 }
40282 {
40283 if (temp4)
40284 delete arg4;
40285 }
40286 {
40287 if (temp5)
40288 delete arg5;
40289 }
40290 return resultobj;
40291 fail:
40292 {
40293 if (temp4)
40294 delete arg4;
40295 }
40296 {
40297 if (temp5)
40298 delete arg5;
40299 }
40300 return NULL;
40301 }
40302
40303
40304 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40305 PyObject *resultobj = 0;
40306 wxMenu *arg1 = (wxMenu *) 0 ;
40307 size_t arg2 ;
40308 wxMenuItem *result = 0 ;
40309 void *argp1 = 0 ;
40310 int res1 = 0 ;
40311 size_t val2 ;
40312 int ecode2 = 0 ;
40313 PyObject * obj0 = 0 ;
40314 PyObject * obj1 = 0 ;
40315 char * kwnames[] = {
40316 (char *) "self",(char *) "pos", NULL
40317 };
40318
40319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40321 if (!SWIG_IsOK(res1)) {
40322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40323 }
40324 arg1 = reinterpret_cast< wxMenu * >(argp1);
40325 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40326 if (!SWIG_IsOK(ecode2)) {
40327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40328 }
40329 arg2 = static_cast< size_t >(val2);
40330 {
40331 PyThreadState* __tstate = wxPyBeginAllowThreads();
40332 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40333 wxPyEndAllowThreads(__tstate);
40334 if (PyErr_Occurred()) SWIG_fail;
40335 }
40336 {
40337 resultobj = wxPyMake_wxObject(result, (bool)0);
40338 }
40339 return resultobj;
40340 fail:
40341 return NULL;
40342 }
40343
40344
40345 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40346 PyObject *resultobj = 0;
40347 wxMenu *arg1 = (wxMenu *) 0 ;
40348 size_t arg2 ;
40349 int arg3 ;
40350 wxString *arg4 = 0 ;
40351 wxString const &arg5_defvalue = wxPyEmptyString ;
40352 wxString *arg5 = (wxString *) &arg5_defvalue ;
40353 wxMenuItem *result = 0 ;
40354 void *argp1 = 0 ;
40355 int res1 = 0 ;
40356 size_t val2 ;
40357 int ecode2 = 0 ;
40358 int val3 ;
40359 int ecode3 = 0 ;
40360 bool temp4 = false ;
40361 bool temp5 = false ;
40362 PyObject * obj0 = 0 ;
40363 PyObject * obj1 = 0 ;
40364 PyObject * obj2 = 0 ;
40365 PyObject * obj3 = 0 ;
40366 PyObject * obj4 = 0 ;
40367 char * kwnames[] = {
40368 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40369 };
40370
40371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40373 if (!SWIG_IsOK(res1)) {
40374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40375 }
40376 arg1 = reinterpret_cast< wxMenu * >(argp1);
40377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40378 if (!SWIG_IsOK(ecode2)) {
40379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40380 }
40381 arg2 = static_cast< size_t >(val2);
40382 ecode3 = SWIG_AsVal_int(obj2, &val3);
40383 if (!SWIG_IsOK(ecode3)) {
40384 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40385 }
40386 arg3 = static_cast< int >(val3);
40387 {
40388 arg4 = wxString_in_helper(obj3);
40389 if (arg4 == NULL) SWIG_fail;
40390 temp4 = true;
40391 }
40392 if (obj4) {
40393 {
40394 arg5 = wxString_in_helper(obj4);
40395 if (arg5 == NULL) SWIG_fail;
40396 temp5 = true;
40397 }
40398 }
40399 {
40400 PyThreadState* __tstate = wxPyBeginAllowThreads();
40401 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40402 wxPyEndAllowThreads(__tstate);
40403 if (PyErr_Occurred()) SWIG_fail;
40404 }
40405 {
40406 resultobj = wxPyMake_wxObject(result, (bool)0);
40407 }
40408 {
40409 if (temp4)
40410 delete arg4;
40411 }
40412 {
40413 if (temp5)
40414 delete arg5;
40415 }
40416 return resultobj;
40417 fail:
40418 {
40419 if (temp4)
40420 delete arg4;
40421 }
40422 {
40423 if (temp5)
40424 delete arg5;
40425 }
40426 return NULL;
40427 }
40428
40429
40430 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40431 PyObject *resultobj = 0;
40432 wxMenu *arg1 = (wxMenu *) 0 ;
40433 size_t arg2 ;
40434 int arg3 ;
40435 wxString *arg4 = 0 ;
40436 wxString const &arg5_defvalue = wxPyEmptyString ;
40437 wxString *arg5 = (wxString *) &arg5_defvalue ;
40438 wxMenuItem *result = 0 ;
40439 void *argp1 = 0 ;
40440 int res1 = 0 ;
40441 size_t val2 ;
40442 int ecode2 = 0 ;
40443 int val3 ;
40444 int ecode3 = 0 ;
40445 bool temp4 = false ;
40446 bool temp5 = false ;
40447 PyObject * obj0 = 0 ;
40448 PyObject * obj1 = 0 ;
40449 PyObject * obj2 = 0 ;
40450 PyObject * obj3 = 0 ;
40451 PyObject * obj4 = 0 ;
40452 char * kwnames[] = {
40453 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40454 };
40455
40456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40458 if (!SWIG_IsOK(res1)) {
40459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40460 }
40461 arg1 = reinterpret_cast< wxMenu * >(argp1);
40462 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40463 if (!SWIG_IsOK(ecode2)) {
40464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40465 }
40466 arg2 = static_cast< size_t >(val2);
40467 ecode3 = SWIG_AsVal_int(obj2, &val3);
40468 if (!SWIG_IsOK(ecode3)) {
40469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40470 }
40471 arg3 = static_cast< int >(val3);
40472 {
40473 arg4 = wxString_in_helper(obj3);
40474 if (arg4 == NULL) SWIG_fail;
40475 temp4 = true;
40476 }
40477 if (obj4) {
40478 {
40479 arg5 = wxString_in_helper(obj4);
40480 if (arg5 == NULL) SWIG_fail;
40481 temp5 = true;
40482 }
40483 }
40484 {
40485 PyThreadState* __tstate = wxPyBeginAllowThreads();
40486 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40487 wxPyEndAllowThreads(__tstate);
40488 if (PyErr_Occurred()) SWIG_fail;
40489 }
40490 {
40491 resultobj = wxPyMake_wxObject(result, (bool)0);
40492 }
40493 {
40494 if (temp4)
40495 delete arg4;
40496 }
40497 {
40498 if (temp5)
40499 delete arg5;
40500 }
40501 return resultobj;
40502 fail:
40503 {
40504 if (temp4)
40505 delete arg4;
40506 }
40507 {
40508 if (temp5)
40509 delete arg5;
40510 }
40511 return NULL;
40512 }
40513
40514
40515 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40516 PyObject *resultobj = 0;
40517 wxMenu *arg1 = (wxMenu *) 0 ;
40518 size_t arg2 ;
40519 int arg3 ;
40520 wxString *arg4 = 0 ;
40521 wxMenu *arg5 = (wxMenu *) 0 ;
40522 wxString const &arg6_defvalue = wxPyEmptyString ;
40523 wxString *arg6 = (wxString *) &arg6_defvalue ;
40524 wxMenuItem *result = 0 ;
40525 void *argp1 = 0 ;
40526 int res1 = 0 ;
40527 size_t val2 ;
40528 int ecode2 = 0 ;
40529 int val3 ;
40530 int ecode3 = 0 ;
40531 bool temp4 = false ;
40532 void *argp5 = 0 ;
40533 int res5 = 0 ;
40534 bool temp6 = false ;
40535 PyObject * obj0 = 0 ;
40536 PyObject * obj1 = 0 ;
40537 PyObject * obj2 = 0 ;
40538 PyObject * obj3 = 0 ;
40539 PyObject * obj4 = 0 ;
40540 PyObject * obj5 = 0 ;
40541 char * kwnames[] = {
40542 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40543 };
40544
40545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40547 if (!SWIG_IsOK(res1)) {
40548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40549 }
40550 arg1 = reinterpret_cast< wxMenu * >(argp1);
40551 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40552 if (!SWIG_IsOK(ecode2)) {
40553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40554 }
40555 arg2 = static_cast< size_t >(val2);
40556 ecode3 = SWIG_AsVal_int(obj2, &val3);
40557 if (!SWIG_IsOK(ecode3)) {
40558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40559 }
40560 arg3 = static_cast< int >(val3);
40561 {
40562 arg4 = wxString_in_helper(obj3);
40563 if (arg4 == NULL) SWIG_fail;
40564 temp4 = true;
40565 }
40566 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40567 if (!SWIG_IsOK(res5)) {
40568 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40569 }
40570 arg5 = reinterpret_cast< wxMenu * >(argp5);
40571 if (obj5) {
40572 {
40573 arg6 = wxString_in_helper(obj5);
40574 if (arg6 == NULL) SWIG_fail;
40575 temp6 = true;
40576 }
40577 }
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 {
40585 resultobj = wxPyMake_wxObject(result, (bool)0);
40586 }
40587 {
40588 if (temp4)
40589 delete arg4;
40590 }
40591 {
40592 if (temp6)
40593 delete arg6;
40594 }
40595 return resultobj;
40596 fail:
40597 {
40598 if (temp4)
40599 delete arg4;
40600 }
40601 {
40602 if (temp6)
40603 delete arg6;
40604 }
40605 return NULL;
40606 }
40607
40608
40609 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj = 0;
40611 wxMenu *arg1 = (wxMenu *) 0 ;
40612 int arg2 ;
40613 wxString const &arg3_defvalue = wxPyEmptyString ;
40614 wxString *arg3 = (wxString *) &arg3_defvalue ;
40615 wxString const &arg4_defvalue = wxPyEmptyString ;
40616 wxString *arg4 = (wxString *) &arg4_defvalue ;
40617 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40618 wxMenuItem *result = 0 ;
40619 void *argp1 = 0 ;
40620 int res1 = 0 ;
40621 int val2 ;
40622 int ecode2 = 0 ;
40623 bool temp3 = false ;
40624 bool temp4 = false ;
40625 int val5 ;
40626 int ecode5 = 0 ;
40627 PyObject * obj0 = 0 ;
40628 PyObject * obj1 = 0 ;
40629 PyObject * obj2 = 0 ;
40630 PyObject * obj3 = 0 ;
40631 PyObject * obj4 = 0 ;
40632 char * kwnames[] = {
40633 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40634 };
40635
40636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40638 if (!SWIG_IsOK(res1)) {
40639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40640 }
40641 arg1 = reinterpret_cast< wxMenu * >(argp1);
40642 ecode2 = SWIG_AsVal_int(obj1, &val2);
40643 if (!SWIG_IsOK(ecode2)) {
40644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40645 }
40646 arg2 = static_cast< int >(val2);
40647 if (obj2) {
40648 {
40649 arg3 = wxString_in_helper(obj2);
40650 if (arg3 == NULL) SWIG_fail;
40651 temp3 = true;
40652 }
40653 }
40654 if (obj3) {
40655 {
40656 arg4 = wxString_in_helper(obj3);
40657 if (arg4 == NULL) SWIG_fail;
40658 temp4 = true;
40659 }
40660 }
40661 if (obj4) {
40662 ecode5 = SWIG_AsVal_int(obj4, &val5);
40663 if (!SWIG_IsOK(ecode5)) {
40664 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40665 }
40666 arg5 = static_cast< wxItemKind >(val5);
40667 }
40668 {
40669 PyThreadState* __tstate = wxPyBeginAllowThreads();
40670 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40671 wxPyEndAllowThreads(__tstate);
40672 if (PyErr_Occurred()) SWIG_fail;
40673 }
40674 {
40675 resultobj = wxPyMake_wxObject(result, (bool)0);
40676 }
40677 {
40678 if (temp3)
40679 delete arg3;
40680 }
40681 {
40682 if (temp4)
40683 delete arg4;
40684 }
40685 return resultobj;
40686 fail:
40687 {
40688 if (temp3)
40689 delete arg3;
40690 }
40691 {
40692 if (temp4)
40693 delete arg4;
40694 }
40695 return NULL;
40696 }
40697
40698
40699 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40700 PyObject *resultobj = 0;
40701 wxMenu *arg1 = (wxMenu *) 0 ;
40702 wxMenuItem *result = 0 ;
40703 void *argp1 = 0 ;
40704 int res1 = 0 ;
40705 PyObject *swig_obj[1] ;
40706
40707 if (!args) SWIG_fail;
40708 swig_obj[0] = args;
40709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40710 if (!SWIG_IsOK(res1)) {
40711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40712 }
40713 arg1 = reinterpret_cast< wxMenu * >(argp1);
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 result = (wxMenuItem *)(arg1)->PrependSeparator();
40717 wxPyEndAllowThreads(__tstate);
40718 if (PyErr_Occurred()) SWIG_fail;
40719 }
40720 {
40721 resultobj = wxPyMake_wxObject(result, (bool)0);
40722 }
40723 return resultobj;
40724 fail:
40725 return NULL;
40726 }
40727
40728
40729 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40730 PyObject *resultobj = 0;
40731 wxMenu *arg1 = (wxMenu *) 0 ;
40732 int arg2 ;
40733 wxString *arg3 = 0 ;
40734 wxString const &arg4_defvalue = wxPyEmptyString ;
40735 wxString *arg4 = (wxString *) &arg4_defvalue ;
40736 wxMenuItem *result = 0 ;
40737 void *argp1 = 0 ;
40738 int res1 = 0 ;
40739 int val2 ;
40740 int ecode2 = 0 ;
40741 bool temp3 = false ;
40742 bool temp4 = false ;
40743 PyObject * obj0 = 0 ;
40744 PyObject * obj1 = 0 ;
40745 PyObject * obj2 = 0 ;
40746 PyObject * obj3 = 0 ;
40747 char * kwnames[] = {
40748 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40749 };
40750
40751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40753 if (!SWIG_IsOK(res1)) {
40754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40755 }
40756 arg1 = reinterpret_cast< wxMenu * >(argp1);
40757 ecode2 = SWIG_AsVal_int(obj1, &val2);
40758 if (!SWIG_IsOK(ecode2)) {
40759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40760 }
40761 arg2 = static_cast< int >(val2);
40762 {
40763 arg3 = wxString_in_helper(obj2);
40764 if (arg3 == NULL) SWIG_fail;
40765 temp3 = true;
40766 }
40767 if (obj3) {
40768 {
40769 arg4 = wxString_in_helper(obj3);
40770 if (arg4 == NULL) SWIG_fail;
40771 temp4 = true;
40772 }
40773 }
40774 {
40775 PyThreadState* __tstate = wxPyBeginAllowThreads();
40776 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40777 wxPyEndAllowThreads(__tstate);
40778 if (PyErr_Occurred()) SWIG_fail;
40779 }
40780 {
40781 resultobj = wxPyMake_wxObject(result, (bool)0);
40782 }
40783 {
40784 if (temp3)
40785 delete arg3;
40786 }
40787 {
40788 if (temp4)
40789 delete arg4;
40790 }
40791 return resultobj;
40792 fail:
40793 {
40794 if (temp3)
40795 delete arg3;
40796 }
40797 {
40798 if (temp4)
40799 delete arg4;
40800 }
40801 return NULL;
40802 }
40803
40804
40805 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40806 PyObject *resultobj = 0;
40807 wxMenu *arg1 = (wxMenu *) 0 ;
40808 int arg2 ;
40809 wxString *arg3 = 0 ;
40810 wxString const &arg4_defvalue = wxPyEmptyString ;
40811 wxString *arg4 = (wxString *) &arg4_defvalue ;
40812 wxMenuItem *result = 0 ;
40813 void *argp1 = 0 ;
40814 int res1 = 0 ;
40815 int val2 ;
40816 int ecode2 = 0 ;
40817 bool temp3 = false ;
40818 bool temp4 = false ;
40819 PyObject * obj0 = 0 ;
40820 PyObject * obj1 = 0 ;
40821 PyObject * obj2 = 0 ;
40822 PyObject * obj3 = 0 ;
40823 char * kwnames[] = {
40824 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40825 };
40826
40827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40829 if (!SWIG_IsOK(res1)) {
40830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40831 }
40832 arg1 = reinterpret_cast< wxMenu * >(argp1);
40833 ecode2 = SWIG_AsVal_int(obj1, &val2);
40834 if (!SWIG_IsOK(ecode2)) {
40835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40836 }
40837 arg2 = static_cast< int >(val2);
40838 {
40839 arg3 = wxString_in_helper(obj2);
40840 if (arg3 == NULL) SWIG_fail;
40841 temp3 = true;
40842 }
40843 if (obj3) {
40844 {
40845 arg4 = wxString_in_helper(obj3);
40846 if (arg4 == NULL) SWIG_fail;
40847 temp4 = true;
40848 }
40849 }
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = wxPyMake_wxObject(result, (bool)0);
40858 }
40859 {
40860 if (temp3)
40861 delete arg3;
40862 }
40863 {
40864 if (temp4)
40865 delete arg4;
40866 }
40867 return resultobj;
40868 fail:
40869 {
40870 if (temp3)
40871 delete arg3;
40872 }
40873 {
40874 if (temp4)
40875 delete arg4;
40876 }
40877 return NULL;
40878 }
40879
40880
40881 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40882 PyObject *resultobj = 0;
40883 wxMenu *arg1 = (wxMenu *) 0 ;
40884 int arg2 ;
40885 wxString *arg3 = 0 ;
40886 wxMenu *arg4 = (wxMenu *) 0 ;
40887 wxString const &arg5_defvalue = wxPyEmptyString ;
40888 wxString *arg5 = (wxString *) &arg5_defvalue ;
40889 wxMenuItem *result = 0 ;
40890 void *argp1 = 0 ;
40891 int res1 = 0 ;
40892 int val2 ;
40893 int ecode2 = 0 ;
40894 bool temp3 = false ;
40895 void *argp4 = 0 ;
40896 int res4 = 0 ;
40897 bool temp5 = false ;
40898 PyObject * obj0 = 0 ;
40899 PyObject * obj1 = 0 ;
40900 PyObject * obj2 = 0 ;
40901 PyObject * obj3 = 0 ;
40902 PyObject * obj4 = 0 ;
40903 char * kwnames[] = {
40904 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40905 };
40906
40907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40909 if (!SWIG_IsOK(res1)) {
40910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40911 }
40912 arg1 = reinterpret_cast< wxMenu * >(argp1);
40913 ecode2 = SWIG_AsVal_int(obj1, &val2);
40914 if (!SWIG_IsOK(ecode2)) {
40915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40916 }
40917 arg2 = static_cast< int >(val2);
40918 {
40919 arg3 = wxString_in_helper(obj2);
40920 if (arg3 == NULL) SWIG_fail;
40921 temp3 = true;
40922 }
40923 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40924 if (!SWIG_IsOK(res4)) {
40925 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40926 }
40927 arg4 = reinterpret_cast< wxMenu * >(argp4);
40928 if (obj4) {
40929 {
40930 arg5 = wxString_in_helper(obj4);
40931 if (arg5 == NULL) SWIG_fail;
40932 temp5 = true;
40933 }
40934 }
40935 {
40936 PyThreadState* __tstate = wxPyBeginAllowThreads();
40937 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40938 wxPyEndAllowThreads(__tstate);
40939 if (PyErr_Occurred()) SWIG_fail;
40940 }
40941 {
40942 resultobj = wxPyMake_wxObject(result, (bool)0);
40943 }
40944 {
40945 if (temp3)
40946 delete arg3;
40947 }
40948 {
40949 if (temp5)
40950 delete arg5;
40951 }
40952 return resultobj;
40953 fail:
40954 {
40955 if (temp3)
40956 delete arg3;
40957 }
40958 {
40959 if (temp5)
40960 delete arg5;
40961 }
40962 return NULL;
40963 }
40964
40965
40966 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj = 0;
40968 wxMenu *arg1 = (wxMenu *) 0 ;
40969 int arg2 ;
40970 wxMenuItem *result = 0 ;
40971 void *argp1 = 0 ;
40972 int res1 = 0 ;
40973 int val2 ;
40974 int ecode2 = 0 ;
40975 PyObject * obj0 = 0 ;
40976 PyObject * obj1 = 0 ;
40977 char * kwnames[] = {
40978 (char *) "self",(char *) "id", NULL
40979 };
40980
40981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40983 if (!SWIG_IsOK(res1)) {
40984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40985 }
40986 arg1 = reinterpret_cast< wxMenu * >(argp1);
40987 ecode2 = SWIG_AsVal_int(obj1, &val2);
40988 if (!SWIG_IsOK(ecode2)) {
40989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40990 }
40991 arg2 = static_cast< int >(val2);
40992 {
40993 PyThreadState* __tstate = wxPyBeginAllowThreads();
40994 result = (wxMenuItem *)(arg1)->Remove(arg2);
40995 wxPyEndAllowThreads(__tstate);
40996 if (PyErr_Occurred()) SWIG_fail;
40997 }
40998 {
40999 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41000 }
41001 return resultobj;
41002 fail:
41003 return NULL;
41004 }
41005
41006
41007 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41008 PyObject *resultobj = 0;
41009 wxMenu *arg1 = (wxMenu *) 0 ;
41010 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41011 wxMenuItem *result = 0 ;
41012 void *argp1 = 0 ;
41013 int res1 = 0 ;
41014 void *argp2 = 0 ;
41015 int res2 = 0 ;
41016 PyObject * obj0 = 0 ;
41017 PyObject * obj1 = 0 ;
41018 char * kwnames[] = {
41019 (char *) "self",(char *) "item", NULL
41020 };
41021
41022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
41023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41024 if (!SWIG_IsOK(res1)) {
41025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41026 }
41027 arg1 = reinterpret_cast< wxMenu * >(argp1);
41028 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41029 if (!SWIG_IsOK(res2)) {
41030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41031 }
41032 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41033 {
41034 PyThreadState* __tstate = wxPyBeginAllowThreads();
41035 result = (wxMenuItem *)(arg1)->Remove(arg2);
41036 wxPyEndAllowThreads(__tstate);
41037 if (PyErr_Occurred()) SWIG_fail;
41038 }
41039 {
41040 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41041 }
41042 return resultobj;
41043 fail:
41044 return NULL;
41045 }
41046
41047
41048 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj = 0;
41050 wxMenu *arg1 = (wxMenu *) 0 ;
41051 int arg2 ;
41052 bool result;
41053 void *argp1 = 0 ;
41054 int res1 = 0 ;
41055 int val2 ;
41056 int ecode2 = 0 ;
41057 PyObject * obj0 = 0 ;
41058 PyObject * obj1 = 0 ;
41059 char * kwnames[] = {
41060 (char *) "self",(char *) "id", NULL
41061 };
41062
41063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41067 }
41068 arg1 = reinterpret_cast< wxMenu * >(argp1);
41069 ecode2 = SWIG_AsVal_int(obj1, &val2);
41070 if (!SWIG_IsOK(ecode2)) {
41071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41072 }
41073 arg2 = static_cast< int >(val2);
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = (bool)(arg1)->Delete(arg2);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41082 }
41083 return resultobj;
41084 fail:
41085 return NULL;
41086 }
41087
41088
41089 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj = 0;
41091 wxMenu *arg1 = (wxMenu *) 0 ;
41092 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41093 bool result;
41094 void *argp1 = 0 ;
41095 int res1 = 0 ;
41096 void *argp2 = 0 ;
41097 int res2 = 0 ;
41098 PyObject * obj0 = 0 ;
41099 PyObject * obj1 = 0 ;
41100 char * kwnames[] = {
41101 (char *) "self",(char *) "item", NULL
41102 };
41103
41104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41106 if (!SWIG_IsOK(res1)) {
41107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41108 }
41109 arg1 = reinterpret_cast< wxMenu * >(argp1);
41110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41111 if (!SWIG_IsOK(res2)) {
41112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41113 }
41114 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41115 {
41116 PyThreadState* __tstate = wxPyBeginAllowThreads();
41117 result = (bool)(arg1)->Delete(arg2);
41118 wxPyEndAllowThreads(__tstate);
41119 if (PyErr_Occurred()) SWIG_fail;
41120 }
41121 {
41122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41123 }
41124 return resultobj;
41125 fail:
41126 return NULL;
41127 }
41128
41129
41130 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41131 PyObject *resultobj = 0;
41132 wxMenu *arg1 = (wxMenu *) 0 ;
41133 void *argp1 = 0 ;
41134 int res1 = 0 ;
41135 PyObject *swig_obj[1] ;
41136
41137 if (!args) SWIG_fail;
41138 swig_obj[0] = args;
41139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41140 if (!SWIG_IsOK(res1)) {
41141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41142 }
41143 arg1 = reinterpret_cast< wxMenu * >(argp1);
41144 {
41145 PyThreadState* __tstate = wxPyBeginAllowThreads();
41146 wxMenu_Destroy(arg1);
41147 wxPyEndAllowThreads(__tstate);
41148 if (PyErr_Occurred()) SWIG_fail;
41149 }
41150 resultobj = SWIG_Py_Void();
41151 return resultobj;
41152 fail:
41153 return NULL;
41154 }
41155
41156
41157 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41158 PyObject *resultobj = 0;
41159 wxMenu *arg1 = (wxMenu *) 0 ;
41160 int arg2 ;
41161 bool result;
41162 void *argp1 = 0 ;
41163 int res1 = 0 ;
41164 int val2 ;
41165 int ecode2 = 0 ;
41166 PyObject * obj0 = 0 ;
41167 PyObject * obj1 = 0 ;
41168 char * kwnames[] = {
41169 (char *) "self",(char *) "id", NULL
41170 };
41171
41172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41174 if (!SWIG_IsOK(res1)) {
41175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41176 }
41177 arg1 = reinterpret_cast< wxMenu * >(argp1);
41178 ecode2 = SWIG_AsVal_int(obj1, &val2);
41179 if (!SWIG_IsOK(ecode2)) {
41180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41181 }
41182 arg2 = static_cast< int >(val2);
41183 {
41184 PyThreadState* __tstate = wxPyBeginAllowThreads();
41185 result = (bool)(arg1)->Destroy(arg2);
41186 wxPyEndAllowThreads(__tstate);
41187 if (PyErr_Occurred()) SWIG_fail;
41188 }
41189 {
41190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41191 }
41192 return resultobj;
41193 fail:
41194 return NULL;
41195 }
41196
41197
41198 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41199 PyObject *resultobj = 0;
41200 wxMenu *arg1 = (wxMenu *) 0 ;
41201 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41202 bool result;
41203 void *argp1 = 0 ;
41204 int res1 = 0 ;
41205 void *argp2 = 0 ;
41206 int res2 = 0 ;
41207 PyObject * obj0 = 0 ;
41208 PyObject * obj1 = 0 ;
41209 char * kwnames[] = {
41210 (char *) "self",(char *) "item", NULL
41211 };
41212
41213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41215 if (!SWIG_IsOK(res1)) {
41216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41217 }
41218 arg1 = reinterpret_cast< wxMenu * >(argp1);
41219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41220 if (!SWIG_IsOK(res2)) {
41221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41222 }
41223 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41224 {
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 result = (bool)(arg1)->Destroy(arg2);
41227 wxPyEndAllowThreads(__tstate);
41228 if (PyErr_Occurred()) SWIG_fail;
41229 }
41230 {
41231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41232 }
41233 return resultobj;
41234 fail:
41235 return NULL;
41236 }
41237
41238
41239 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41240 PyObject *resultobj = 0;
41241 wxMenu *arg1 = (wxMenu *) 0 ;
41242 size_t result;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 PyObject *swig_obj[1] ;
41246
41247 if (!args) SWIG_fail;
41248 swig_obj[0] = args;
41249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenu * >(argp1);
41254 {
41255 PyThreadState* __tstate = wxPyBeginAllowThreads();
41256 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41257 wxPyEndAllowThreads(__tstate);
41258 if (PyErr_Occurred()) SWIG_fail;
41259 }
41260 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41261 return resultobj;
41262 fail:
41263 return NULL;
41264 }
41265
41266
41267 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41268 PyObject *resultobj = 0;
41269 wxMenu *arg1 = (wxMenu *) 0 ;
41270 PyObject *result = 0 ;
41271 void *argp1 = 0 ;
41272 int res1 = 0 ;
41273 PyObject *swig_obj[1] ;
41274
41275 if (!args) SWIG_fail;
41276 swig_obj[0] = args;
41277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41278 if (!SWIG_IsOK(res1)) {
41279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41280 }
41281 arg1 = reinterpret_cast< wxMenu * >(argp1);
41282 {
41283 PyThreadState* __tstate = wxPyBeginAllowThreads();
41284 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41285 wxPyEndAllowThreads(__tstate);
41286 if (PyErr_Occurred()) SWIG_fail;
41287 }
41288 resultobj = result;
41289 return resultobj;
41290 fail:
41291 return NULL;
41292 }
41293
41294
41295 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41296 PyObject *resultobj = 0;
41297 wxMenu *arg1 = (wxMenu *) 0 ;
41298 wxString *arg2 = 0 ;
41299 int result;
41300 void *argp1 = 0 ;
41301 int res1 = 0 ;
41302 bool temp2 = false ;
41303 PyObject * obj0 = 0 ;
41304 PyObject * obj1 = 0 ;
41305 char * kwnames[] = {
41306 (char *) "self",(char *) "item", NULL
41307 };
41308
41309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41311 if (!SWIG_IsOK(res1)) {
41312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41313 }
41314 arg1 = reinterpret_cast< wxMenu * >(argp1);
41315 {
41316 arg2 = wxString_in_helper(obj1);
41317 if (arg2 == NULL) SWIG_fail;
41318 temp2 = true;
41319 }
41320 {
41321 PyThreadState* __tstate = wxPyBeginAllowThreads();
41322 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41323 wxPyEndAllowThreads(__tstate);
41324 if (PyErr_Occurred()) SWIG_fail;
41325 }
41326 resultobj = SWIG_From_int(static_cast< int >(result));
41327 {
41328 if (temp2)
41329 delete arg2;
41330 }
41331 return resultobj;
41332 fail:
41333 {
41334 if (temp2)
41335 delete arg2;
41336 }
41337 return NULL;
41338 }
41339
41340
41341 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41342 PyObject *resultobj = 0;
41343 wxMenu *arg1 = (wxMenu *) 0 ;
41344 int arg2 ;
41345 wxMenuItem *result = 0 ;
41346 void *argp1 = 0 ;
41347 int res1 = 0 ;
41348 int val2 ;
41349 int ecode2 = 0 ;
41350 PyObject * obj0 = 0 ;
41351 PyObject * obj1 = 0 ;
41352 char * kwnames[] = {
41353 (char *) "self",(char *) "id", NULL
41354 };
41355
41356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41358 if (!SWIG_IsOK(res1)) {
41359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41360 }
41361 arg1 = reinterpret_cast< wxMenu * >(argp1);
41362 ecode2 = SWIG_AsVal_int(obj1, &val2);
41363 if (!SWIG_IsOK(ecode2)) {
41364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41365 }
41366 arg2 = static_cast< int >(val2);
41367 {
41368 PyThreadState* __tstate = wxPyBeginAllowThreads();
41369 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41370 wxPyEndAllowThreads(__tstate);
41371 if (PyErr_Occurred()) SWIG_fail;
41372 }
41373 {
41374 resultobj = wxPyMake_wxObject(result, (bool)0);
41375 }
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj = 0;
41384 wxMenu *arg1 = (wxMenu *) 0 ;
41385 size_t arg2 ;
41386 wxMenuItem *result = 0 ;
41387 void *argp1 = 0 ;
41388 int res1 = 0 ;
41389 size_t val2 ;
41390 int ecode2 = 0 ;
41391 PyObject * obj0 = 0 ;
41392 PyObject * obj1 = 0 ;
41393 char * kwnames[] = {
41394 (char *) "self",(char *) "position", NULL
41395 };
41396
41397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41399 if (!SWIG_IsOK(res1)) {
41400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41401 }
41402 arg1 = reinterpret_cast< wxMenu * >(argp1);
41403 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41404 if (!SWIG_IsOK(ecode2)) {
41405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41406 }
41407 arg2 = static_cast< size_t >(val2);
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41411 wxPyEndAllowThreads(__tstate);
41412 if (PyErr_Occurred()) SWIG_fail;
41413 }
41414 {
41415 resultobj = wxPyMake_wxObject(result, (bool)0);
41416 }
41417 return resultobj;
41418 fail:
41419 return NULL;
41420 }
41421
41422
41423 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41424 PyObject *resultobj = 0;
41425 wxMenu *arg1 = (wxMenu *) 0 ;
41426 int arg2 ;
41427 bool arg3 ;
41428 void *argp1 = 0 ;
41429 int res1 = 0 ;
41430 int val2 ;
41431 int ecode2 = 0 ;
41432 bool val3 ;
41433 int ecode3 = 0 ;
41434 PyObject * obj0 = 0 ;
41435 PyObject * obj1 = 0 ;
41436 PyObject * obj2 = 0 ;
41437 char * kwnames[] = {
41438 (char *) "self",(char *) "id",(char *) "enable", NULL
41439 };
41440
41441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41443 if (!SWIG_IsOK(res1)) {
41444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41445 }
41446 arg1 = reinterpret_cast< wxMenu * >(argp1);
41447 ecode2 = SWIG_AsVal_int(obj1, &val2);
41448 if (!SWIG_IsOK(ecode2)) {
41449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41450 }
41451 arg2 = static_cast< int >(val2);
41452 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41453 if (!SWIG_IsOK(ecode3)) {
41454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41455 }
41456 arg3 = static_cast< bool >(val3);
41457 {
41458 PyThreadState* __tstate = wxPyBeginAllowThreads();
41459 (arg1)->Enable(arg2,arg3);
41460 wxPyEndAllowThreads(__tstate);
41461 if (PyErr_Occurred()) SWIG_fail;
41462 }
41463 resultobj = SWIG_Py_Void();
41464 return resultobj;
41465 fail:
41466 return NULL;
41467 }
41468
41469
41470 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41471 PyObject *resultobj = 0;
41472 wxMenu *arg1 = (wxMenu *) 0 ;
41473 int arg2 ;
41474 bool result;
41475 void *argp1 = 0 ;
41476 int res1 = 0 ;
41477 int val2 ;
41478 int ecode2 = 0 ;
41479 PyObject * obj0 = 0 ;
41480 PyObject * obj1 = 0 ;
41481 char * kwnames[] = {
41482 (char *) "self",(char *) "id", NULL
41483 };
41484
41485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41487 if (!SWIG_IsOK(res1)) {
41488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41489 }
41490 arg1 = reinterpret_cast< wxMenu * >(argp1);
41491 ecode2 = SWIG_AsVal_int(obj1, &val2);
41492 if (!SWIG_IsOK(ecode2)) {
41493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41494 }
41495 arg2 = static_cast< int >(val2);
41496 {
41497 PyThreadState* __tstate = wxPyBeginAllowThreads();
41498 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41499 wxPyEndAllowThreads(__tstate);
41500 if (PyErr_Occurred()) SWIG_fail;
41501 }
41502 {
41503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41504 }
41505 return resultobj;
41506 fail:
41507 return NULL;
41508 }
41509
41510
41511 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41512 PyObject *resultobj = 0;
41513 wxMenu *arg1 = (wxMenu *) 0 ;
41514 int arg2 ;
41515 bool arg3 ;
41516 void *argp1 = 0 ;
41517 int res1 = 0 ;
41518 int val2 ;
41519 int ecode2 = 0 ;
41520 bool val3 ;
41521 int ecode3 = 0 ;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 PyObject * obj2 = 0 ;
41525 char * kwnames[] = {
41526 (char *) "self",(char *) "id",(char *) "check", NULL
41527 };
41528
41529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",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_Check" "', 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_Check" "', expected argument " "2"" of type '" "int""'");
41538 }
41539 arg2 = static_cast< int >(val2);
41540 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41541 if (!SWIG_IsOK(ecode3)) {
41542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41543 }
41544 arg3 = static_cast< bool >(val3);
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 (arg1)->Check(arg2,arg3);
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 resultobj = SWIG_Py_Void();
41552 return resultobj;
41553 fail:
41554 return NULL;
41555 }
41556
41557
41558 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41559 PyObject *resultobj = 0;
41560 wxMenu *arg1 = (wxMenu *) 0 ;
41561 int arg2 ;
41562 bool result;
41563 void *argp1 = 0 ;
41564 int res1 = 0 ;
41565 int val2 ;
41566 int ecode2 = 0 ;
41567 PyObject * obj0 = 0 ;
41568 PyObject * obj1 = 0 ;
41569 char * kwnames[] = {
41570 (char *) "self",(char *) "id", NULL
41571 };
41572
41573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41575 if (!SWIG_IsOK(res1)) {
41576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41577 }
41578 arg1 = reinterpret_cast< wxMenu * >(argp1);
41579 ecode2 = SWIG_AsVal_int(obj1, &val2);
41580 if (!SWIG_IsOK(ecode2)) {
41581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41582 }
41583 arg2 = static_cast< int >(val2);
41584 {
41585 PyThreadState* __tstate = wxPyBeginAllowThreads();
41586 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41587 wxPyEndAllowThreads(__tstate);
41588 if (PyErr_Occurred()) SWIG_fail;
41589 }
41590 {
41591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41592 }
41593 return resultobj;
41594 fail:
41595 return NULL;
41596 }
41597
41598
41599 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41600 PyObject *resultobj = 0;
41601 wxMenu *arg1 = (wxMenu *) 0 ;
41602 int arg2 ;
41603 wxString *arg3 = 0 ;
41604 void *argp1 = 0 ;
41605 int res1 = 0 ;
41606 int val2 ;
41607 int ecode2 = 0 ;
41608 bool temp3 = false ;
41609 PyObject * obj0 = 0 ;
41610 PyObject * obj1 = 0 ;
41611 PyObject * obj2 = 0 ;
41612 char * kwnames[] = {
41613 (char *) "self",(char *) "id",(char *) "label", NULL
41614 };
41615
41616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41618 if (!SWIG_IsOK(res1)) {
41619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41620 }
41621 arg1 = reinterpret_cast< wxMenu * >(argp1);
41622 ecode2 = SWIG_AsVal_int(obj1, &val2);
41623 if (!SWIG_IsOK(ecode2)) {
41624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41625 }
41626 arg2 = static_cast< int >(val2);
41627 {
41628 arg3 = wxString_in_helper(obj2);
41629 if (arg3 == NULL) SWIG_fail;
41630 temp3 = true;
41631 }
41632 {
41633 PyThreadState* __tstate = wxPyBeginAllowThreads();
41634 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41635 wxPyEndAllowThreads(__tstate);
41636 if (PyErr_Occurred()) SWIG_fail;
41637 }
41638 resultobj = SWIG_Py_Void();
41639 {
41640 if (temp3)
41641 delete arg3;
41642 }
41643 return resultobj;
41644 fail:
41645 {
41646 if (temp3)
41647 delete arg3;
41648 }
41649 return NULL;
41650 }
41651
41652
41653 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41654 PyObject *resultobj = 0;
41655 wxMenu *arg1 = (wxMenu *) 0 ;
41656 int arg2 ;
41657 wxString result;
41658 void *argp1 = 0 ;
41659 int res1 = 0 ;
41660 int val2 ;
41661 int ecode2 = 0 ;
41662 PyObject * obj0 = 0 ;
41663 PyObject * obj1 = 0 ;
41664 char * kwnames[] = {
41665 (char *) "self",(char *) "id", NULL
41666 };
41667
41668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41670 if (!SWIG_IsOK(res1)) {
41671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41672 }
41673 arg1 = reinterpret_cast< wxMenu * >(argp1);
41674 ecode2 = SWIG_AsVal_int(obj1, &val2);
41675 if (!SWIG_IsOK(ecode2)) {
41676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41677 }
41678 arg2 = static_cast< int >(val2);
41679 {
41680 PyThreadState* __tstate = wxPyBeginAllowThreads();
41681 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41682 wxPyEndAllowThreads(__tstate);
41683 if (PyErr_Occurred()) SWIG_fail;
41684 }
41685 {
41686 #if wxUSE_UNICODE
41687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41688 #else
41689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41690 #endif
41691 }
41692 return resultobj;
41693 fail:
41694 return NULL;
41695 }
41696
41697
41698 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj = 0;
41700 wxMenu *arg1 = (wxMenu *) 0 ;
41701 int arg2 ;
41702 wxString *arg3 = 0 ;
41703 void *argp1 = 0 ;
41704 int res1 = 0 ;
41705 int val2 ;
41706 int ecode2 = 0 ;
41707 bool temp3 = false ;
41708 PyObject * obj0 = 0 ;
41709 PyObject * obj1 = 0 ;
41710 PyObject * obj2 = 0 ;
41711 char * kwnames[] = {
41712 (char *) "self",(char *) "id",(char *) "helpString", NULL
41713 };
41714
41715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41717 if (!SWIG_IsOK(res1)) {
41718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41719 }
41720 arg1 = reinterpret_cast< wxMenu * >(argp1);
41721 ecode2 = SWIG_AsVal_int(obj1, &val2);
41722 if (!SWIG_IsOK(ecode2)) {
41723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41724 }
41725 arg2 = static_cast< int >(val2);
41726 {
41727 arg3 = wxString_in_helper(obj2);
41728 if (arg3 == NULL) SWIG_fail;
41729 temp3 = true;
41730 }
41731 {
41732 PyThreadState* __tstate = wxPyBeginAllowThreads();
41733 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41734 wxPyEndAllowThreads(__tstate);
41735 if (PyErr_Occurred()) SWIG_fail;
41736 }
41737 resultobj = SWIG_Py_Void();
41738 {
41739 if (temp3)
41740 delete arg3;
41741 }
41742 return resultobj;
41743 fail:
41744 {
41745 if (temp3)
41746 delete arg3;
41747 }
41748 return NULL;
41749 }
41750
41751
41752 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj = 0;
41754 wxMenu *arg1 = (wxMenu *) 0 ;
41755 int arg2 ;
41756 wxString result;
41757 void *argp1 = 0 ;
41758 int res1 = 0 ;
41759 int val2 ;
41760 int ecode2 = 0 ;
41761 PyObject * obj0 = 0 ;
41762 PyObject * obj1 = 0 ;
41763 char * kwnames[] = {
41764 (char *) "self",(char *) "id", NULL
41765 };
41766
41767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41769 if (!SWIG_IsOK(res1)) {
41770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41771 }
41772 arg1 = reinterpret_cast< wxMenu * >(argp1);
41773 ecode2 = SWIG_AsVal_int(obj1, &val2);
41774 if (!SWIG_IsOK(ecode2)) {
41775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41776 }
41777 arg2 = static_cast< int >(val2);
41778 {
41779 PyThreadState* __tstate = wxPyBeginAllowThreads();
41780 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41781 wxPyEndAllowThreads(__tstate);
41782 if (PyErr_Occurred()) SWIG_fail;
41783 }
41784 {
41785 #if wxUSE_UNICODE
41786 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41787 #else
41788 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41789 #endif
41790 }
41791 return resultobj;
41792 fail:
41793 return NULL;
41794 }
41795
41796
41797 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41798 PyObject *resultobj = 0;
41799 wxMenu *arg1 = (wxMenu *) 0 ;
41800 wxString *arg2 = 0 ;
41801 void *argp1 = 0 ;
41802 int res1 = 0 ;
41803 bool temp2 = false ;
41804 PyObject * obj0 = 0 ;
41805 PyObject * obj1 = 0 ;
41806 char * kwnames[] = {
41807 (char *) "self",(char *) "title", NULL
41808 };
41809
41810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41812 if (!SWIG_IsOK(res1)) {
41813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41814 }
41815 arg1 = reinterpret_cast< wxMenu * >(argp1);
41816 {
41817 arg2 = wxString_in_helper(obj1);
41818 if (arg2 == NULL) SWIG_fail;
41819 temp2 = true;
41820 }
41821 {
41822 PyThreadState* __tstate = wxPyBeginAllowThreads();
41823 (arg1)->SetTitle((wxString const &)*arg2);
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 resultobj = SWIG_Py_Void();
41828 {
41829 if (temp2)
41830 delete arg2;
41831 }
41832 return resultobj;
41833 fail:
41834 {
41835 if (temp2)
41836 delete arg2;
41837 }
41838 return NULL;
41839 }
41840
41841
41842 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41843 PyObject *resultobj = 0;
41844 wxMenu *arg1 = (wxMenu *) 0 ;
41845 wxString result;
41846 void *argp1 = 0 ;
41847 int res1 = 0 ;
41848 PyObject *swig_obj[1] ;
41849
41850 if (!args) SWIG_fail;
41851 swig_obj[0] = args;
41852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41853 if (!SWIG_IsOK(res1)) {
41854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41855 }
41856 arg1 = reinterpret_cast< wxMenu * >(argp1);
41857 {
41858 PyThreadState* __tstate = wxPyBeginAllowThreads();
41859 result = ((wxMenu const *)arg1)->GetTitle();
41860 wxPyEndAllowThreads(__tstate);
41861 if (PyErr_Occurred()) SWIG_fail;
41862 }
41863 {
41864 #if wxUSE_UNICODE
41865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41866 #else
41867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41868 #endif
41869 }
41870 return resultobj;
41871 fail:
41872 return NULL;
41873 }
41874
41875
41876 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41877 PyObject *resultobj = 0;
41878 wxMenu *arg1 = (wxMenu *) 0 ;
41879 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41880 void *argp1 = 0 ;
41881 int res1 = 0 ;
41882 void *argp2 = 0 ;
41883 int res2 = 0 ;
41884 PyObject * obj0 = 0 ;
41885 PyObject * obj1 = 0 ;
41886 char * kwnames[] = {
41887 (char *) "self",(char *) "handler", NULL
41888 };
41889
41890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41892 if (!SWIG_IsOK(res1)) {
41893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41894 }
41895 arg1 = reinterpret_cast< wxMenu * >(argp1);
41896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41897 if (!SWIG_IsOK(res2)) {
41898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41899 }
41900 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 (arg1)->SetEventHandler(arg2);
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 resultobj = SWIG_Py_Void();
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41915 PyObject *resultobj = 0;
41916 wxMenu *arg1 = (wxMenu *) 0 ;
41917 wxEvtHandler *result = 0 ;
41918 void *argp1 = 0 ;
41919 int res1 = 0 ;
41920 PyObject *swig_obj[1] ;
41921
41922 if (!args) SWIG_fail;
41923 swig_obj[0] = args;
41924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41925 if (!SWIG_IsOK(res1)) {
41926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41927 }
41928 arg1 = reinterpret_cast< wxMenu * >(argp1);
41929 {
41930 PyThreadState* __tstate = wxPyBeginAllowThreads();
41931 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41932 wxPyEndAllowThreads(__tstate);
41933 if (PyErr_Occurred()) SWIG_fail;
41934 }
41935 {
41936 resultobj = wxPyMake_wxObject(result, 0);
41937 }
41938 return resultobj;
41939 fail:
41940 return NULL;
41941 }
41942
41943
41944 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41945 PyObject *resultobj = 0;
41946 wxMenu *arg1 = (wxMenu *) 0 ;
41947 wxWindow *arg2 = (wxWindow *) 0 ;
41948 void *argp1 = 0 ;
41949 int res1 = 0 ;
41950 void *argp2 = 0 ;
41951 int res2 = 0 ;
41952 PyObject * obj0 = 0 ;
41953 PyObject * obj1 = 0 ;
41954 char * kwnames[] = {
41955 (char *) "self",(char *) "win", NULL
41956 };
41957
41958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41960 if (!SWIG_IsOK(res1)) {
41961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41962 }
41963 arg1 = reinterpret_cast< wxMenu * >(argp1);
41964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41965 if (!SWIG_IsOK(res2)) {
41966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41967 }
41968 arg2 = reinterpret_cast< wxWindow * >(argp2);
41969 {
41970 PyThreadState* __tstate = wxPyBeginAllowThreads();
41971 (arg1)->SetInvokingWindow(arg2);
41972 wxPyEndAllowThreads(__tstate);
41973 if (PyErr_Occurred()) SWIG_fail;
41974 }
41975 resultobj = SWIG_Py_Void();
41976 return resultobj;
41977 fail:
41978 return NULL;
41979 }
41980
41981
41982 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41983 PyObject *resultobj = 0;
41984 wxMenu *arg1 = (wxMenu *) 0 ;
41985 wxWindow *result = 0 ;
41986 void *argp1 = 0 ;
41987 int res1 = 0 ;
41988 PyObject *swig_obj[1] ;
41989
41990 if (!args) SWIG_fail;
41991 swig_obj[0] = args;
41992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41993 if (!SWIG_IsOK(res1)) {
41994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41995 }
41996 arg1 = reinterpret_cast< wxMenu * >(argp1);
41997 {
41998 PyThreadState* __tstate = wxPyBeginAllowThreads();
41999 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
42000 wxPyEndAllowThreads(__tstate);
42001 if (PyErr_Occurred()) SWIG_fail;
42002 }
42003 {
42004 resultobj = wxPyMake_wxObject(result, 0);
42005 }
42006 return resultobj;
42007 fail:
42008 return NULL;
42009 }
42010
42011
42012 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42013 PyObject *resultobj = 0;
42014 wxMenu *arg1 = (wxMenu *) 0 ;
42015 long result;
42016 void *argp1 = 0 ;
42017 int res1 = 0 ;
42018 PyObject *swig_obj[1] ;
42019
42020 if (!args) SWIG_fail;
42021 swig_obj[0] = args;
42022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42023 if (!SWIG_IsOK(res1)) {
42024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
42025 }
42026 arg1 = reinterpret_cast< wxMenu * >(argp1);
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 result = (long)((wxMenu const *)arg1)->GetStyle();
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = SWIG_From_long(static_cast< long >(result));
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42041 PyObject *resultobj = 0;
42042 wxMenu *arg1 = (wxMenu *) 0 ;
42043 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42044 void *argp1 = 0 ;
42045 int res1 = 0 ;
42046 void *argp2 = 0 ;
42047 int res2 = 0 ;
42048 PyObject * obj0 = 0 ;
42049 PyObject * obj1 = 0 ;
42050 char * kwnames[] = {
42051 (char *) "self",(char *) "source", NULL
42052 };
42053
42054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42056 if (!SWIG_IsOK(res1)) {
42057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42058 }
42059 arg1 = reinterpret_cast< wxMenu * >(argp1);
42060 if (obj1) {
42061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42062 if (!SWIG_IsOK(res2)) {
42063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42064 }
42065 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42066 }
42067 {
42068 PyThreadState* __tstate = wxPyBeginAllowThreads();
42069 (arg1)->UpdateUI(arg2);
42070 wxPyEndAllowThreads(__tstate);
42071 if (PyErr_Occurred()) SWIG_fail;
42072 }
42073 resultobj = SWIG_Py_Void();
42074 return resultobj;
42075 fail:
42076 return NULL;
42077 }
42078
42079
42080 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42081 PyObject *resultobj = 0;
42082 wxMenu *arg1 = (wxMenu *) 0 ;
42083 wxMenuBar *result = 0 ;
42084 void *argp1 = 0 ;
42085 int res1 = 0 ;
42086 PyObject *swig_obj[1] ;
42087
42088 if (!args) SWIG_fail;
42089 swig_obj[0] = args;
42090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42091 if (!SWIG_IsOK(res1)) {
42092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42093 }
42094 arg1 = reinterpret_cast< wxMenu * >(argp1);
42095 {
42096 PyThreadState* __tstate = wxPyBeginAllowThreads();
42097 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 {
42102 resultobj = wxPyMake_wxObject(result, (bool)0);
42103 }
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42111 PyObject *resultobj = 0;
42112 wxMenu *arg1 = (wxMenu *) 0 ;
42113 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42114 void *argp1 = 0 ;
42115 int res1 = 0 ;
42116 void *argp2 = 0 ;
42117 int res2 = 0 ;
42118 PyObject * obj0 = 0 ;
42119 PyObject * obj1 = 0 ;
42120 char * kwnames[] = {
42121 (char *) "self",(char *) "menubar", NULL
42122 };
42123
42124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42126 if (!SWIG_IsOK(res1)) {
42127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42128 }
42129 arg1 = reinterpret_cast< wxMenu * >(argp1);
42130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42131 if (!SWIG_IsOK(res2)) {
42132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42133 }
42134 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42135 {
42136 PyThreadState* __tstate = wxPyBeginAllowThreads();
42137 (arg1)->Attach(arg2);
42138 wxPyEndAllowThreads(__tstate);
42139 if (PyErr_Occurred()) SWIG_fail;
42140 }
42141 resultobj = SWIG_Py_Void();
42142 return resultobj;
42143 fail:
42144 return NULL;
42145 }
42146
42147
42148 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42149 PyObject *resultobj = 0;
42150 wxMenu *arg1 = (wxMenu *) 0 ;
42151 void *argp1 = 0 ;
42152 int res1 = 0 ;
42153 PyObject *swig_obj[1] ;
42154
42155 if (!args) SWIG_fail;
42156 swig_obj[0] = args;
42157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42158 if (!SWIG_IsOK(res1)) {
42159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42160 }
42161 arg1 = reinterpret_cast< wxMenu * >(argp1);
42162 {
42163 PyThreadState* __tstate = wxPyBeginAllowThreads();
42164 (arg1)->Detach();
42165 wxPyEndAllowThreads(__tstate);
42166 if (PyErr_Occurred()) SWIG_fail;
42167 }
42168 resultobj = SWIG_Py_Void();
42169 return resultobj;
42170 fail:
42171 return NULL;
42172 }
42173
42174
42175 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42176 PyObject *resultobj = 0;
42177 wxMenu *arg1 = (wxMenu *) 0 ;
42178 bool result;
42179 void *argp1 = 0 ;
42180 int res1 = 0 ;
42181 PyObject *swig_obj[1] ;
42182
42183 if (!args) SWIG_fail;
42184 swig_obj[0] = args;
42185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42186 if (!SWIG_IsOK(res1)) {
42187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42188 }
42189 arg1 = reinterpret_cast< wxMenu * >(argp1);
42190 {
42191 PyThreadState* __tstate = wxPyBeginAllowThreads();
42192 result = (bool)((wxMenu const *)arg1)->IsAttached();
42193 wxPyEndAllowThreads(__tstate);
42194 if (PyErr_Occurred()) SWIG_fail;
42195 }
42196 {
42197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42198 }
42199 return resultobj;
42200 fail:
42201 return NULL;
42202 }
42203
42204
42205 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42206 PyObject *resultobj = 0;
42207 wxMenu *arg1 = (wxMenu *) 0 ;
42208 wxMenu *arg2 = (wxMenu *) 0 ;
42209 void *argp1 = 0 ;
42210 int res1 = 0 ;
42211 void *argp2 = 0 ;
42212 int res2 = 0 ;
42213 PyObject * obj0 = 0 ;
42214 PyObject * obj1 = 0 ;
42215 char * kwnames[] = {
42216 (char *) "self",(char *) "parent", NULL
42217 };
42218
42219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42221 if (!SWIG_IsOK(res1)) {
42222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42223 }
42224 arg1 = reinterpret_cast< wxMenu * >(argp1);
42225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42226 if (!SWIG_IsOK(res2)) {
42227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42228 }
42229 arg2 = reinterpret_cast< wxMenu * >(argp2);
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 (arg1)->SetParent(arg2);
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 resultobj = SWIG_Py_Void();
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42244 PyObject *resultobj = 0;
42245 wxMenu *arg1 = (wxMenu *) 0 ;
42246 wxMenu *result = 0 ;
42247 void *argp1 = 0 ;
42248 int res1 = 0 ;
42249 PyObject *swig_obj[1] ;
42250
42251 if (!args) SWIG_fail;
42252 swig_obj[0] = args;
42253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42254 if (!SWIG_IsOK(res1)) {
42255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42256 }
42257 arg1 = reinterpret_cast< wxMenu * >(argp1);
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42261 wxPyEndAllowThreads(__tstate);
42262 if (PyErr_Occurred()) SWIG_fail;
42263 }
42264 {
42265 resultobj = wxPyMake_wxObject(result, 0);
42266 }
42267 return resultobj;
42268 fail:
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42274 PyObject *obj;
42275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42276 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42277 return SWIG_Py_Void();
42278 }
42279
42280 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42281 return SWIG_Python_InitShadowInstance(args);
42282 }
42283
42284 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42285 PyObject *resultobj = 0;
42286 long arg1 = (long) 0 ;
42287 wxMenuBar *result = 0 ;
42288 long val1 ;
42289 int ecode1 = 0 ;
42290 PyObject * obj0 = 0 ;
42291 char * kwnames[] = {
42292 (char *) "style", NULL
42293 };
42294
42295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42296 if (obj0) {
42297 ecode1 = SWIG_AsVal_long(obj0, &val1);
42298 if (!SWIG_IsOK(ecode1)) {
42299 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42300 }
42301 arg1 = static_cast< long >(val1);
42302 }
42303 {
42304 if (!wxPyCheckForApp()) SWIG_fail;
42305 PyThreadState* __tstate = wxPyBeginAllowThreads();
42306 result = (wxMenuBar *)new wxMenuBar(arg1);
42307 wxPyEndAllowThreads(__tstate);
42308 if (PyErr_Occurred()) SWIG_fail;
42309 }
42310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42318 PyObject *resultobj = 0;
42319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42320 wxMenu *arg2 = (wxMenu *) 0 ;
42321 wxString *arg3 = 0 ;
42322 bool result;
42323 void *argp1 = 0 ;
42324 int res1 = 0 ;
42325 void *argp2 = 0 ;
42326 int res2 = 0 ;
42327 bool temp3 = false ;
42328 PyObject * obj0 = 0 ;
42329 PyObject * obj1 = 0 ;
42330 PyObject * obj2 = 0 ;
42331 char * kwnames[] = {
42332 (char *) "self",(char *) "menu",(char *) "title", NULL
42333 };
42334
42335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42337 if (!SWIG_IsOK(res1)) {
42338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42339 }
42340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42341 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42342 if (!SWIG_IsOK(res2)) {
42343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42344 }
42345 arg2 = reinterpret_cast< wxMenu * >(argp2);
42346 {
42347 arg3 = wxString_in_helper(obj2);
42348 if (arg3 == NULL) SWIG_fail;
42349 temp3 = true;
42350 }
42351 {
42352 PyThreadState* __tstate = wxPyBeginAllowThreads();
42353 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42354 wxPyEndAllowThreads(__tstate);
42355 if (PyErr_Occurred()) SWIG_fail;
42356 }
42357 {
42358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42359 }
42360 {
42361 if (temp3)
42362 delete arg3;
42363 }
42364 return resultobj;
42365 fail:
42366 {
42367 if (temp3)
42368 delete arg3;
42369 }
42370 return NULL;
42371 }
42372
42373
42374 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42375 PyObject *resultobj = 0;
42376 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42377 size_t arg2 ;
42378 wxMenu *arg3 = (wxMenu *) 0 ;
42379 wxString *arg4 = 0 ;
42380 bool result;
42381 void *argp1 = 0 ;
42382 int res1 = 0 ;
42383 size_t val2 ;
42384 int ecode2 = 0 ;
42385 void *argp3 = 0 ;
42386 int res3 = 0 ;
42387 bool temp4 = false ;
42388 PyObject * obj0 = 0 ;
42389 PyObject * obj1 = 0 ;
42390 PyObject * obj2 = 0 ;
42391 PyObject * obj3 = 0 ;
42392 char * kwnames[] = {
42393 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42394 };
42395
42396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42398 if (!SWIG_IsOK(res1)) {
42399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42400 }
42401 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42402 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42403 if (!SWIG_IsOK(ecode2)) {
42404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42405 }
42406 arg2 = static_cast< size_t >(val2);
42407 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42408 if (!SWIG_IsOK(res3)) {
42409 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42410 }
42411 arg3 = reinterpret_cast< wxMenu * >(argp3);
42412 {
42413 arg4 = wxString_in_helper(obj3);
42414 if (arg4 == NULL) SWIG_fail;
42415 temp4 = true;
42416 }
42417 {
42418 PyThreadState* __tstate = wxPyBeginAllowThreads();
42419 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42420 wxPyEndAllowThreads(__tstate);
42421 if (PyErr_Occurred()) SWIG_fail;
42422 }
42423 {
42424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42425 }
42426 {
42427 if (temp4)
42428 delete arg4;
42429 }
42430 return resultobj;
42431 fail:
42432 {
42433 if (temp4)
42434 delete arg4;
42435 }
42436 return NULL;
42437 }
42438
42439
42440 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42441 PyObject *resultobj = 0;
42442 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42443 size_t result;
42444 void *argp1 = 0 ;
42445 int res1 = 0 ;
42446 PyObject *swig_obj[1] ;
42447
42448 if (!args) SWIG_fail;
42449 swig_obj[0] = args;
42450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42458 wxPyEndAllowThreads(__tstate);
42459 if (PyErr_Occurred()) SWIG_fail;
42460 }
42461 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42462 return resultobj;
42463 fail:
42464 return NULL;
42465 }
42466
42467
42468 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42469 PyObject *resultobj = 0;
42470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42471 size_t arg2 ;
42472 wxMenu *result = 0 ;
42473 void *argp1 = 0 ;
42474 int res1 = 0 ;
42475 size_t val2 ;
42476 int ecode2 = 0 ;
42477 PyObject * obj0 = 0 ;
42478 PyObject * obj1 = 0 ;
42479 char * kwnames[] = {
42480 (char *) "self",(char *) "pos", NULL
42481 };
42482
42483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42485 if (!SWIG_IsOK(res1)) {
42486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42487 }
42488 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42489 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42490 if (!SWIG_IsOK(ecode2)) {
42491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42492 }
42493 arg2 = static_cast< size_t >(val2);
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 resultobj = wxPyMake_wxObject(result, 0);
42502 }
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42510 PyObject *resultobj = 0;
42511 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42512 size_t arg2 ;
42513 wxMenu *arg3 = (wxMenu *) 0 ;
42514 wxString *arg4 = 0 ;
42515 wxMenu *result = 0 ;
42516 void *argp1 = 0 ;
42517 int res1 = 0 ;
42518 size_t val2 ;
42519 int ecode2 = 0 ;
42520 void *argp3 = 0 ;
42521 int res3 = 0 ;
42522 bool temp4 = false ;
42523 PyObject * obj0 = 0 ;
42524 PyObject * obj1 = 0 ;
42525 PyObject * obj2 = 0 ;
42526 PyObject * obj3 = 0 ;
42527 char * kwnames[] = {
42528 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42529 };
42530
42531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42533 if (!SWIG_IsOK(res1)) {
42534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42535 }
42536 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42537 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42538 if (!SWIG_IsOK(ecode2)) {
42539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42540 }
42541 arg2 = static_cast< size_t >(val2);
42542 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42543 if (!SWIG_IsOK(res3)) {
42544 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42545 }
42546 arg3 = reinterpret_cast< wxMenu * >(argp3);
42547 {
42548 arg4 = wxString_in_helper(obj3);
42549 if (arg4 == NULL) SWIG_fail;
42550 temp4 = true;
42551 }
42552 {
42553 PyThreadState* __tstate = wxPyBeginAllowThreads();
42554 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42555 wxPyEndAllowThreads(__tstate);
42556 if (PyErr_Occurred()) SWIG_fail;
42557 }
42558 {
42559 resultobj = wxPyMake_wxObject(result, 0);
42560 }
42561 {
42562 if (temp4)
42563 delete arg4;
42564 }
42565 return resultobj;
42566 fail:
42567 {
42568 if (temp4)
42569 delete arg4;
42570 }
42571 return NULL;
42572 }
42573
42574
42575 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42576 PyObject *resultobj = 0;
42577 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42578 size_t arg2 ;
42579 wxMenu *result = 0 ;
42580 void *argp1 = 0 ;
42581 int res1 = 0 ;
42582 size_t val2 ;
42583 int ecode2 = 0 ;
42584 PyObject * obj0 = 0 ;
42585 PyObject * obj1 = 0 ;
42586 char * kwnames[] = {
42587 (char *) "self",(char *) "pos", NULL
42588 };
42589
42590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42592 if (!SWIG_IsOK(res1)) {
42593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42594 }
42595 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42596 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42597 if (!SWIG_IsOK(ecode2)) {
42598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42599 }
42600 arg2 = static_cast< size_t >(val2);
42601 {
42602 PyThreadState* __tstate = wxPyBeginAllowThreads();
42603 result = (wxMenu *)(arg1)->Remove(arg2);
42604 wxPyEndAllowThreads(__tstate);
42605 if (PyErr_Occurred()) SWIG_fail;
42606 }
42607 {
42608 resultobj = wxPyMake_wxObject(result, 0);
42609 }
42610 return resultobj;
42611 fail:
42612 return NULL;
42613 }
42614
42615
42616 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42617 PyObject *resultobj = 0;
42618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42619 size_t arg2 ;
42620 bool arg3 ;
42621 void *argp1 = 0 ;
42622 int res1 = 0 ;
42623 size_t val2 ;
42624 int ecode2 = 0 ;
42625 bool val3 ;
42626 int ecode3 = 0 ;
42627 PyObject * obj0 = 0 ;
42628 PyObject * obj1 = 0 ;
42629 PyObject * obj2 = 0 ;
42630 char * kwnames[] = {
42631 (char *) "self",(char *) "pos",(char *) "enable", NULL
42632 };
42633
42634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",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_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42638 }
42639 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42640 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42641 if (!SWIG_IsOK(ecode2)) {
42642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42643 }
42644 arg2 = static_cast< size_t >(val2);
42645 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42646 if (!SWIG_IsOK(ecode3)) {
42647 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42648 }
42649 arg3 = static_cast< bool >(val3);
42650 {
42651 PyThreadState* __tstate = wxPyBeginAllowThreads();
42652 (arg1)->EnableTop(arg2,arg3);
42653 wxPyEndAllowThreads(__tstate);
42654 if (PyErr_Occurred()) SWIG_fail;
42655 }
42656 resultobj = SWIG_Py_Void();
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42664 PyObject *resultobj = 0;
42665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42666 size_t arg2 ;
42667 bool result;
42668 void *argp1 = 0 ;
42669 int res1 = 0 ;
42670 size_t val2 ;
42671 int ecode2 = 0 ;
42672 PyObject * obj0 = 0 ;
42673 PyObject * obj1 = 0 ;
42674 char * kwnames[] = {
42675 (char *) "self",(char *) "pos", NULL
42676 };
42677
42678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42680 if (!SWIG_IsOK(res1)) {
42681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42682 }
42683 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42685 if (!SWIG_IsOK(ecode2)) {
42686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42687 }
42688 arg2 = static_cast< size_t >(val2);
42689 {
42690 PyThreadState* __tstate = wxPyBeginAllowThreads();
42691 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42692 wxPyEndAllowThreads(__tstate);
42693 if (PyErr_Occurred()) SWIG_fail;
42694 }
42695 {
42696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42697 }
42698 return resultobj;
42699 fail:
42700 return NULL;
42701 }
42702
42703
42704 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42705 PyObject *resultobj = 0;
42706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42707 size_t arg2 ;
42708 wxString *arg3 = 0 ;
42709 void *argp1 = 0 ;
42710 int res1 = 0 ;
42711 size_t val2 ;
42712 int ecode2 = 0 ;
42713 bool temp3 = false ;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 PyObject * obj2 = 0 ;
42717 char * kwnames[] = {
42718 (char *) "self",(char *) "pos",(char *) "label", NULL
42719 };
42720
42721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42723 if (!SWIG_IsOK(res1)) {
42724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42725 }
42726 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42727 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42728 if (!SWIG_IsOK(ecode2)) {
42729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42730 }
42731 arg2 = static_cast< size_t >(val2);
42732 {
42733 arg3 = wxString_in_helper(obj2);
42734 if (arg3 == NULL) SWIG_fail;
42735 temp3 = true;
42736 }
42737 {
42738 PyThreadState* __tstate = wxPyBeginAllowThreads();
42739 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 resultobj = SWIG_Py_Void();
42744 {
42745 if (temp3)
42746 delete arg3;
42747 }
42748 return resultobj;
42749 fail:
42750 {
42751 if (temp3)
42752 delete arg3;
42753 }
42754 return NULL;
42755 }
42756
42757
42758 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42759 PyObject *resultobj = 0;
42760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42761 size_t arg2 ;
42762 wxString result;
42763 void *argp1 = 0 ;
42764 int res1 = 0 ;
42765 size_t val2 ;
42766 int ecode2 = 0 ;
42767 PyObject * obj0 = 0 ;
42768 PyObject * obj1 = 0 ;
42769 char * kwnames[] = {
42770 (char *) "self",(char *) "pos", NULL
42771 };
42772
42773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42775 if (!SWIG_IsOK(res1)) {
42776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42777 }
42778 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42779 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42780 if (!SWIG_IsOK(ecode2)) {
42781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42782 }
42783 arg2 = static_cast< size_t >(val2);
42784 {
42785 PyThreadState* __tstate = wxPyBeginAllowThreads();
42786 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42787 wxPyEndAllowThreads(__tstate);
42788 if (PyErr_Occurred()) SWIG_fail;
42789 }
42790 {
42791 #if wxUSE_UNICODE
42792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42793 #else
42794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42795 #endif
42796 }
42797 return resultobj;
42798 fail:
42799 return NULL;
42800 }
42801
42802
42803 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42804 PyObject *resultobj = 0;
42805 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42806 wxString *arg2 = 0 ;
42807 wxString *arg3 = 0 ;
42808 int result;
42809 void *argp1 = 0 ;
42810 int res1 = 0 ;
42811 bool temp2 = false ;
42812 bool temp3 = false ;
42813 PyObject * obj0 = 0 ;
42814 PyObject * obj1 = 0 ;
42815 PyObject * obj2 = 0 ;
42816 char * kwnames[] = {
42817 (char *) "self",(char *) "menu",(char *) "item", NULL
42818 };
42819
42820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42822 if (!SWIG_IsOK(res1)) {
42823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42824 }
42825 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42826 {
42827 arg2 = wxString_in_helper(obj1);
42828 if (arg2 == NULL) SWIG_fail;
42829 temp2 = true;
42830 }
42831 {
42832 arg3 = wxString_in_helper(obj2);
42833 if (arg3 == NULL) SWIG_fail;
42834 temp3 = true;
42835 }
42836 {
42837 PyThreadState* __tstate = wxPyBeginAllowThreads();
42838 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42839 wxPyEndAllowThreads(__tstate);
42840 if (PyErr_Occurred()) SWIG_fail;
42841 }
42842 resultobj = SWIG_From_int(static_cast< int >(result));
42843 {
42844 if (temp2)
42845 delete arg2;
42846 }
42847 {
42848 if (temp3)
42849 delete arg3;
42850 }
42851 return resultobj;
42852 fail:
42853 {
42854 if (temp2)
42855 delete arg2;
42856 }
42857 {
42858 if (temp3)
42859 delete arg3;
42860 }
42861 return NULL;
42862 }
42863
42864
42865 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42866 PyObject *resultobj = 0;
42867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42868 int arg2 ;
42869 wxMenuItem *result = 0 ;
42870 void *argp1 = 0 ;
42871 int res1 = 0 ;
42872 int val2 ;
42873 int ecode2 = 0 ;
42874 PyObject * obj0 = 0 ;
42875 PyObject * obj1 = 0 ;
42876 char * kwnames[] = {
42877 (char *) "self",(char *) "id", NULL
42878 };
42879
42880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42882 if (!SWIG_IsOK(res1)) {
42883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42884 }
42885 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42886 ecode2 = SWIG_AsVal_int(obj1, &val2);
42887 if (!SWIG_IsOK(ecode2)) {
42888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42889 }
42890 arg2 = static_cast< int >(val2);
42891 {
42892 PyThreadState* __tstate = wxPyBeginAllowThreads();
42893 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42894 wxPyEndAllowThreads(__tstate);
42895 if (PyErr_Occurred()) SWIG_fail;
42896 }
42897 {
42898 resultobj = wxPyMake_wxObject(result, (bool)0);
42899 }
42900 return resultobj;
42901 fail:
42902 return NULL;
42903 }
42904
42905
42906 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42907 PyObject *resultobj = 0;
42908 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42909 wxString *arg2 = 0 ;
42910 int result;
42911 void *argp1 = 0 ;
42912 int res1 = 0 ;
42913 bool temp2 = false ;
42914 PyObject * obj0 = 0 ;
42915 PyObject * obj1 = 0 ;
42916 char * kwnames[] = {
42917 (char *) "self",(char *) "title", NULL
42918 };
42919
42920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42922 if (!SWIG_IsOK(res1)) {
42923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42924 }
42925 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42926 {
42927 arg2 = wxString_in_helper(obj1);
42928 if (arg2 == NULL) SWIG_fail;
42929 temp2 = true;
42930 }
42931 {
42932 PyThreadState* __tstate = wxPyBeginAllowThreads();
42933 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42934 wxPyEndAllowThreads(__tstate);
42935 if (PyErr_Occurred()) SWIG_fail;
42936 }
42937 resultobj = SWIG_From_int(static_cast< int >(result));
42938 {
42939 if (temp2)
42940 delete arg2;
42941 }
42942 return resultobj;
42943 fail:
42944 {
42945 if (temp2)
42946 delete arg2;
42947 }
42948 return NULL;
42949 }
42950
42951
42952 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42953 PyObject *resultobj = 0;
42954 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42955 int arg2 ;
42956 bool arg3 ;
42957 void *argp1 = 0 ;
42958 int res1 = 0 ;
42959 int val2 ;
42960 int ecode2 = 0 ;
42961 bool val3 ;
42962 int ecode3 = 0 ;
42963 PyObject * obj0 = 0 ;
42964 PyObject * obj1 = 0 ;
42965 PyObject * obj2 = 0 ;
42966 char * kwnames[] = {
42967 (char *) "self",(char *) "id",(char *) "enable", NULL
42968 };
42969
42970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42972 if (!SWIG_IsOK(res1)) {
42973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42974 }
42975 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42976 ecode2 = SWIG_AsVal_int(obj1, &val2);
42977 if (!SWIG_IsOK(ecode2)) {
42978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42979 }
42980 arg2 = static_cast< int >(val2);
42981 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42982 if (!SWIG_IsOK(ecode3)) {
42983 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42984 }
42985 arg3 = static_cast< bool >(val3);
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 (arg1)->Enable(arg2,arg3);
42989 wxPyEndAllowThreads(__tstate);
42990 if (PyErr_Occurred()) SWIG_fail;
42991 }
42992 resultobj = SWIG_Py_Void();
42993 return resultobj;
42994 fail:
42995 return NULL;
42996 }
42997
42998
42999 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43000 PyObject *resultobj = 0;
43001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43002 int arg2 ;
43003 bool arg3 ;
43004 void *argp1 = 0 ;
43005 int res1 = 0 ;
43006 int val2 ;
43007 int ecode2 = 0 ;
43008 bool val3 ;
43009 int ecode3 = 0 ;
43010 PyObject * obj0 = 0 ;
43011 PyObject * obj1 = 0 ;
43012 PyObject * obj2 = 0 ;
43013 char * kwnames[] = {
43014 (char *) "self",(char *) "id",(char *) "check", NULL
43015 };
43016
43017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43019 if (!SWIG_IsOK(res1)) {
43020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43021 }
43022 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43023 ecode2 = SWIG_AsVal_int(obj1, &val2);
43024 if (!SWIG_IsOK(ecode2)) {
43025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
43026 }
43027 arg2 = static_cast< int >(val2);
43028 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43029 if (!SWIG_IsOK(ecode3)) {
43030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43031 }
43032 arg3 = static_cast< bool >(val3);
43033 {
43034 PyThreadState* __tstate = wxPyBeginAllowThreads();
43035 (arg1)->Check(arg2,arg3);
43036 wxPyEndAllowThreads(__tstate);
43037 if (PyErr_Occurred()) SWIG_fail;
43038 }
43039 resultobj = SWIG_Py_Void();
43040 return resultobj;
43041 fail:
43042 return NULL;
43043 }
43044
43045
43046 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43047 PyObject *resultobj = 0;
43048 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43049 int arg2 ;
43050 bool result;
43051 void *argp1 = 0 ;
43052 int res1 = 0 ;
43053 int val2 ;
43054 int ecode2 = 0 ;
43055 PyObject * obj0 = 0 ;
43056 PyObject * obj1 = 0 ;
43057 char * kwnames[] = {
43058 (char *) "self",(char *) "id", NULL
43059 };
43060
43061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43067 ecode2 = SWIG_AsVal_int(obj1, &val2);
43068 if (!SWIG_IsOK(ecode2)) {
43069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43070 }
43071 arg2 = static_cast< int >(val2);
43072 {
43073 PyThreadState* __tstate = wxPyBeginAllowThreads();
43074 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43075 wxPyEndAllowThreads(__tstate);
43076 if (PyErr_Occurred()) SWIG_fail;
43077 }
43078 {
43079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43080 }
43081 return resultobj;
43082 fail:
43083 return NULL;
43084 }
43085
43086
43087 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43088 PyObject *resultobj = 0;
43089 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43090 int arg2 ;
43091 bool result;
43092 void *argp1 = 0 ;
43093 int res1 = 0 ;
43094 int val2 ;
43095 int ecode2 = 0 ;
43096 PyObject * obj0 = 0 ;
43097 PyObject * obj1 = 0 ;
43098 char * kwnames[] = {
43099 (char *) "self",(char *) "id", NULL
43100 };
43101
43102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43104 if (!SWIG_IsOK(res1)) {
43105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43106 }
43107 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43108 ecode2 = SWIG_AsVal_int(obj1, &val2);
43109 if (!SWIG_IsOK(ecode2)) {
43110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43111 }
43112 arg2 = static_cast< int >(val2);
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43116 wxPyEndAllowThreads(__tstate);
43117 if (PyErr_Occurred()) SWIG_fail;
43118 }
43119 {
43120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43121 }
43122 return resultobj;
43123 fail:
43124 return NULL;
43125 }
43126
43127
43128 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43129 PyObject *resultobj = 0;
43130 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43131 int arg2 ;
43132 wxString *arg3 = 0 ;
43133 void *argp1 = 0 ;
43134 int res1 = 0 ;
43135 int val2 ;
43136 int ecode2 = 0 ;
43137 bool temp3 = false ;
43138 PyObject * obj0 = 0 ;
43139 PyObject * obj1 = 0 ;
43140 PyObject * obj2 = 0 ;
43141 char * kwnames[] = {
43142 (char *) "self",(char *) "id",(char *) "label", NULL
43143 };
43144
43145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43147 if (!SWIG_IsOK(res1)) {
43148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43149 }
43150 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43151 ecode2 = SWIG_AsVal_int(obj1, &val2);
43152 if (!SWIG_IsOK(ecode2)) {
43153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43154 }
43155 arg2 = static_cast< int >(val2);
43156 {
43157 arg3 = wxString_in_helper(obj2);
43158 if (arg3 == NULL) SWIG_fail;
43159 temp3 = true;
43160 }
43161 {
43162 PyThreadState* __tstate = wxPyBeginAllowThreads();
43163 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43164 wxPyEndAllowThreads(__tstate);
43165 if (PyErr_Occurred()) SWIG_fail;
43166 }
43167 resultobj = SWIG_Py_Void();
43168 {
43169 if (temp3)
43170 delete arg3;
43171 }
43172 return resultobj;
43173 fail:
43174 {
43175 if (temp3)
43176 delete arg3;
43177 }
43178 return NULL;
43179 }
43180
43181
43182 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43183 PyObject *resultobj = 0;
43184 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43185 int arg2 ;
43186 wxString result;
43187 void *argp1 = 0 ;
43188 int res1 = 0 ;
43189 int val2 ;
43190 int ecode2 = 0 ;
43191 PyObject * obj0 = 0 ;
43192 PyObject * obj1 = 0 ;
43193 char * kwnames[] = {
43194 (char *) "self",(char *) "id", NULL
43195 };
43196
43197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43203 ecode2 = SWIG_AsVal_int(obj1, &val2);
43204 if (!SWIG_IsOK(ecode2)) {
43205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43206 }
43207 arg2 = static_cast< int >(val2);
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 {
43215 #if wxUSE_UNICODE
43216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43217 #else
43218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43219 #endif
43220 }
43221 return resultobj;
43222 fail:
43223 return NULL;
43224 }
43225
43226
43227 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43228 PyObject *resultobj = 0;
43229 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43230 int arg2 ;
43231 wxString *arg3 = 0 ;
43232 void *argp1 = 0 ;
43233 int res1 = 0 ;
43234 int val2 ;
43235 int ecode2 = 0 ;
43236 bool temp3 = false ;
43237 PyObject * obj0 = 0 ;
43238 PyObject * obj1 = 0 ;
43239 PyObject * obj2 = 0 ;
43240 char * kwnames[] = {
43241 (char *) "self",(char *) "id",(char *) "helpString", NULL
43242 };
43243
43244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43246 if (!SWIG_IsOK(res1)) {
43247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43248 }
43249 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43250 ecode2 = SWIG_AsVal_int(obj1, &val2);
43251 if (!SWIG_IsOK(ecode2)) {
43252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43253 }
43254 arg2 = static_cast< int >(val2);
43255 {
43256 arg3 = wxString_in_helper(obj2);
43257 if (arg3 == NULL) SWIG_fail;
43258 temp3 = true;
43259 }
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43263 wxPyEndAllowThreads(__tstate);
43264 if (PyErr_Occurred()) SWIG_fail;
43265 }
43266 resultobj = SWIG_Py_Void();
43267 {
43268 if (temp3)
43269 delete arg3;
43270 }
43271 return resultobj;
43272 fail:
43273 {
43274 if (temp3)
43275 delete arg3;
43276 }
43277 return NULL;
43278 }
43279
43280
43281 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43282 PyObject *resultobj = 0;
43283 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43284 int arg2 ;
43285 wxString result;
43286 void *argp1 = 0 ;
43287 int res1 = 0 ;
43288 int val2 ;
43289 int ecode2 = 0 ;
43290 PyObject * obj0 = 0 ;
43291 PyObject * obj1 = 0 ;
43292 char * kwnames[] = {
43293 (char *) "self",(char *) "id", NULL
43294 };
43295
43296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43298 if (!SWIG_IsOK(res1)) {
43299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43300 }
43301 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43302 ecode2 = SWIG_AsVal_int(obj1, &val2);
43303 if (!SWIG_IsOK(ecode2)) {
43304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43305 }
43306 arg2 = static_cast< int >(val2);
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 {
43314 #if wxUSE_UNICODE
43315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43316 #else
43317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43318 #endif
43319 }
43320 return resultobj;
43321 fail:
43322 return NULL;
43323 }
43324
43325
43326 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43327 PyObject *resultobj = 0;
43328 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43329 wxFrame *result = 0 ;
43330 void *argp1 = 0 ;
43331 int res1 = 0 ;
43332 PyObject *swig_obj[1] ;
43333
43334 if (!args) SWIG_fail;
43335 swig_obj[0] = args;
43336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43341 {
43342 PyThreadState* __tstate = wxPyBeginAllowThreads();
43343 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 {
43348 resultobj = wxPyMake_wxObject(result, (bool)0);
43349 }
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43357 PyObject *resultobj = 0;
43358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43359 bool result;
43360 void *argp1 = 0 ;
43361 int res1 = 0 ;
43362 PyObject *swig_obj[1] ;
43363
43364 if (!args) SWIG_fail;
43365 swig_obj[0] = args;
43366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43367 if (!SWIG_IsOK(res1)) {
43368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43369 }
43370 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43371 {
43372 PyThreadState* __tstate = wxPyBeginAllowThreads();
43373 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43374 wxPyEndAllowThreads(__tstate);
43375 if (PyErr_Occurred()) SWIG_fail;
43376 }
43377 {
43378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43379 }
43380 return resultobj;
43381 fail:
43382 return NULL;
43383 }
43384
43385
43386 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43387 PyObject *resultobj = 0;
43388 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43389 wxFrame *arg2 = (wxFrame *) 0 ;
43390 void *argp1 = 0 ;
43391 int res1 = 0 ;
43392 void *argp2 = 0 ;
43393 int res2 = 0 ;
43394 PyObject * obj0 = 0 ;
43395 PyObject * obj1 = 0 ;
43396 char * kwnames[] = {
43397 (char *) "self",(char *) "frame", NULL
43398 };
43399
43400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43402 if (!SWIG_IsOK(res1)) {
43403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43404 }
43405 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43406 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43407 if (!SWIG_IsOK(res2)) {
43408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43409 }
43410 arg2 = reinterpret_cast< wxFrame * >(argp2);
43411 {
43412 PyThreadState* __tstate = wxPyBeginAllowThreads();
43413 (arg1)->Attach(arg2);
43414 wxPyEndAllowThreads(__tstate);
43415 if (PyErr_Occurred()) SWIG_fail;
43416 }
43417 resultobj = SWIG_Py_Void();
43418 return resultobj;
43419 fail:
43420 return NULL;
43421 }
43422
43423
43424 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43425 PyObject *resultobj = 0;
43426 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43427 void *argp1 = 0 ;
43428 int res1 = 0 ;
43429 PyObject *swig_obj[1] ;
43430
43431 if (!args) SWIG_fail;
43432 swig_obj[0] = args;
43433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43434 if (!SWIG_IsOK(res1)) {
43435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43436 }
43437 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43438 {
43439 PyThreadState* __tstate = wxPyBeginAllowThreads();
43440 (arg1)->Detach();
43441 wxPyEndAllowThreads(__tstate);
43442 if (PyErr_Occurred()) SWIG_fail;
43443 }
43444 resultobj = SWIG_Py_Void();
43445 return resultobj;
43446 fail:
43447 return NULL;
43448 }
43449
43450
43451 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43452 PyObject *resultobj = 0;
43453 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43454 void *argp1 = 0 ;
43455 int res1 = 0 ;
43456 PyObject *swig_obj[1] ;
43457
43458 if (!args) SWIG_fail;
43459 swig_obj[0] = args;
43460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43461 if (!SWIG_IsOK(res1)) {
43462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43463 }
43464 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43465 {
43466 PyThreadState* __tstate = wxPyBeginAllowThreads();
43467 (arg1)->UpdateMenus();
43468 wxPyEndAllowThreads(__tstate);
43469 if (PyErr_Occurred()) SWIG_fail;
43470 }
43471 resultobj = SWIG_Py_Void();
43472 return resultobj;
43473 fail:
43474 return NULL;
43475 }
43476
43477
43478 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43479 PyObject *resultobj = 0;
43480 bool arg1 ;
43481 bool val1 ;
43482 int ecode1 = 0 ;
43483 PyObject * obj0 = 0 ;
43484 char * kwnames[] = {
43485 (char *) "enable", NULL
43486 };
43487
43488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43489 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43490 if (!SWIG_IsOK(ecode1)) {
43491 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43492 }
43493 arg1 = static_cast< bool >(val1);
43494 {
43495 PyThreadState* __tstate = wxPyBeginAllowThreads();
43496 wxMenuBar_SetAutoWindowMenu(arg1);
43497 wxPyEndAllowThreads(__tstate);
43498 if (PyErr_Occurred()) SWIG_fail;
43499 }
43500 resultobj = SWIG_Py_Void();
43501 return resultobj;
43502 fail:
43503 return NULL;
43504 }
43505
43506
43507 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43508 PyObject *resultobj = 0;
43509 bool result;
43510
43511 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43512 {
43513 PyThreadState* __tstate = wxPyBeginAllowThreads();
43514 result = (bool)wxMenuBar_GetAutoWindowMenu();
43515 wxPyEndAllowThreads(__tstate);
43516 if (PyErr_Occurred()) SWIG_fail;
43517 }
43518 {
43519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43520 }
43521 return resultobj;
43522 fail:
43523 return NULL;
43524 }
43525
43526
43527 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43528 PyObject *obj;
43529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43530 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43531 return SWIG_Py_Void();
43532 }
43533
43534 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43535 return SWIG_Python_InitShadowInstance(args);
43536 }
43537
43538 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43539 PyObject *resultobj = 0;
43540 wxMenu *arg1 = (wxMenu *) NULL ;
43541 int arg2 = (int) wxID_ANY ;
43542 wxString const &arg3_defvalue = wxPyEmptyString ;
43543 wxString *arg3 = (wxString *) &arg3_defvalue ;
43544 wxString const &arg4_defvalue = wxPyEmptyString ;
43545 wxString *arg4 = (wxString *) &arg4_defvalue ;
43546 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43547 wxMenu *arg6 = (wxMenu *) NULL ;
43548 wxMenuItem *result = 0 ;
43549 void *argp1 = 0 ;
43550 int res1 = 0 ;
43551 int val2 ;
43552 int ecode2 = 0 ;
43553 bool temp3 = false ;
43554 bool temp4 = false ;
43555 int val5 ;
43556 int ecode5 = 0 ;
43557 void *argp6 = 0 ;
43558 int res6 = 0 ;
43559 PyObject * obj0 = 0 ;
43560 PyObject * obj1 = 0 ;
43561 PyObject * obj2 = 0 ;
43562 PyObject * obj3 = 0 ;
43563 PyObject * obj4 = 0 ;
43564 PyObject * obj5 = 0 ;
43565 char * kwnames[] = {
43566 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43567 };
43568
43569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43570 if (obj0) {
43571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43572 if (!SWIG_IsOK(res1)) {
43573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43574 }
43575 arg1 = reinterpret_cast< wxMenu * >(argp1);
43576 }
43577 if (obj1) {
43578 ecode2 = SWIG_AsVal_int(obj1, &val2);
43579 if (!SWIG_IsOK(ecode2)) {
43580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43581 }
43582 arg2 = static_cast< int >(val2);
43583 }
43584 if (obj2) {
43585 {
43586 arg3 = wxString_in_helper(obj2);
43587 if (arg3 == NULL) SWIG_fail;
43588 temp3 = true;
43589 }
43590 }
43591 if (obj3) {
43592 {
43593 arg4 = wxString_in_helper(obj3);
43594 if (arg4 == NULL) SWIG_fail;
43595 temp4 = true;
43596 }
43597 }
43598 if (obj4) {
43599 ecode5 = SWIG_AsVal_int(obj4, &val5);
43600 if (!SWIG_IsOK(ecode5)) {
43601 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43602 }
43603 arg5 = static_cast< wxItemKind >(val5);
43604 }
43605 if (obj5) {
43606 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43607 if (!SWIG_IsOK(res6)) {
43608 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43609 }
43610 arg6 = reinterpret_cast< wxMenu * >(argp6);
43611 }
43612 {
43613 PyThreadState* __tstate = wxPyBeginAllowThreads();
43614 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43615 wxPyEndAllowThreads(__tstate);
43616 if (PyErr_Occurred()) SWIG_fail;
43617 }
43618 {
43619 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43620 }
43621 {
43622 if (temp3)
43623 delete arg3;
43624 }
43625 {
43626 if (temp4)
43627 delete arg4;
43628 }
43629 return resultobj;
43630 fail:
43631 {
43632 if (temp3)
43633 delete arg3;
43634 }
43635 {
43636 if (temp4)
43637 delete arg4;
43638 }
43639 return NULL;
43640 }
43641
43642
43643 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43644 PyObject *resultobj = 0;
43645 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43646 void *argp1 = 0 ;
43647 int res1 = 0 ;
43648 PyObject *swig_obj[1] ;
43649
43650 if (!args) SWIG_fail;
43651 swig_obj[0] = args;
43652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43653 if (!SWIG_IsOK(res1)) {
43654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43655 }
43656 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43657 {
43658 PyThreadState* __tstate = wxPyBeginAllowThreads();
43659 delete arg1;
43660
43661 wxPyEndAllowThreads(__tstate);
43662 if (PyErr_Occurred()) SWIG_fail;
43663 }
43664 resultobj = SWIG_Py_Void();
43665 return resultobj;
43666 fail:
43667 return NULL;
43668 }
43669
43670
43671 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43672 PyObject *resultobj = 0;
43673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43674 wxMenu *result = 0 ;
43675 void *argp1 = 0 ;
43676 int res1 = 0 ;
43677 PyObject *swig_obj[1] ;
43678
43679 if (!args) SWIG_fail;
43680 swig_obj[0] = args;
43681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43682 if (!SWIG_IsOK(res1)) {
43683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43684 }
43685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 resultobj = wxPyMake_wxObject(result, 0);
43694 }
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43702 PyObject *resultobj = 0;
43703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43704 wxMenu *arg2 = (wxMenu *) 0 ;
43705 void *argp1 = 0 ;
43706 int res1 = 0 ;
43707 void *argp2 = 0 ;
43708 int res2 = 0 ;
43709 PyObject * obj0 = 0 ;
43710 PyObject * obj1 = 0 ;
43711 char * kwnames[] = {
43712 (char *) "self",(char *) "menu", NULL
43713 };
43714
43715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43717 if (!SWIG_IsOK(res1)) {
43718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43719 }
43720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43722 if (!SWIG_IsOK(res2)) {
43723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43724 }
43725 arg2 = reinterpret_cast< wxMenu * >(argp2);
43726 {
43727 PyThreadState* __tstate = wxPyBeginAllowThreads();
43728 (arg1)->SetMenu(arg2);
43729 wxPyEndAllowThreads(__tstate);
43730 if (PyErr_Occurred()) SWIG_fail;
43731 }
43732 resultobj = SWIG_Py_Void();
43733 return resultobj;
43734 fail:
43735 return NULL;
43736 }
43737
43738
43739 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43740 PyObject *resultobj = 0;
43741 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43742 int arg2 ;
43743 void *argp1 = 0 ;
43744 int res1 = 0 ;
43745 int val2 ;
43746 int ecode2 = 0 ;
43747 PyObject * obj0 = 0 ;
43748 PyObject * obj1 = 0 ;
43749 char * kwnames[] = {
43750 (char *) "self",(char *) "id", NULL
43751 };
43752
43753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43757 }
43758 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43759 ecode2 = SWIG_AsVal_int(obj1, &val2);
43760 if (!SWIG_IsOK(ecode2)) {
43761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43762 }
43763 arg2 = static_cast< int >(val2);
43764 {
43765 PyThreadState* __tstate = wxPyBeginAllowThreads();
43766 (arg1)->SetId(arg2);
43767 wxPyEndAllowThreads(__tstate);
43768 if (PyErr_Occurred()) SWIG_fail;
43769 }
43770 resultobj = SWIG_Py_Void();
43771 return resultobj;
43772 fail:
43773 return NULL;
43774 }
43775
43776
43777 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43778 PyObject *resultobj = 0;
43779 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43780 int result;
43781 void *argp1 = 0 ;
43782 int res1 = 0 ;
43783 PyObject *swig_obj[1] ;
43784
43785 if (!args) SWIG_fail;
43786 swig_obj[0] = args;
43787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43788 if (!SWIG_IsOK(res1)) {
43789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43790 }
43791 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43792 {
43793 PyThreadState* __tstate = wxPyBeginAllowThreads();
43794 result = (int)((wxMenuItem const *)arg1)->GetId();
43795 wxPyEndAllowThreads(__tstate);
43796 if (PyErr_Occurred()) SWIG_fail;
43797 }
43798 resultobj = SWIG_From_int(static_cast< int >(result));
43799 return resultobj;
43800 fail:
43801 return NULL;
43802 }
43803
43804
43805 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43806 PyObject *resultobj = 0;
43807 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43808 bool result;
43809 void *argp1 = 0 ;
43810 int res1 = 0 ;
43811 PyObject *swig_obj[1] ;
43812
43813 if (!args) SWIG_fail;
43814 swig_obj[0] = args;
43815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43816 if (!SWIG_IsOK(res1)) {
43817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43818 }
43819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43820 {
43821 PyThreadState* __tstate = wxPyBeginAllowThreads();
43822 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43823 wxPyEndAllowThreads(__tstate);
43824 if (PyErr_Occurred()) SWIG_fail;
43825 }
43826 {
43827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43828 }
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43836 PyObject *resultobj = 0;
43837 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43838 wxString *arg2 = 0 ;
43839 void *argp1 = 0 ;
43840 int res1 = 0 ;
43841 bool temp2 = false ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "str", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43852 }
43853 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43854 {
43855 arg2 = wxString_in_helper(obj1);
43856 if (arg2 == NULL) SWIG_fail;
43857 temp2 = true;
43858 }
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 (arg1)->SetText((wxString const &)*arg2);
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 resultobj = SWIG_Py_Void();
43866 {
43867 if (temp2)
43868 delete arg2;
43869 }
43870 return resultobj;
43871 fail:
43872 {
43873 if (temp2)
43874 delete arg2;
43875 }
43876 return NULL;
43877 }
43878
43879
43880 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43881 PyObject *resultobj = 0;
43882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43883 wxString result;
43884 void *argp1 = 0 ;
43885 int res1 = 0 ;
43886 PyObject *swig_obj[1] ;
43887
43888 if (!args) SWIG_fail;
43889 swig_obj[0] = args;
43890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43891 if (!SWIG_IsOK(res1)) {
43892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43893 }
43894 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43895 {
43896 PyThreadState* __tstate = wxPyBeginAllowThreads();
43897 result = ((wxMenuItem const *)arg1)->GetLabel();
43898 wxPyEndAllowThreads(__tstate);
43899 if (PyErr_Occurred()) SWIG_fail;
43900 }
43901 {
43902 #if wxUSE_UNICODE
43903 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43904 #else
43905 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43906 #endif
43907 }
43908 return resultobj;
43909 fail:
43910 return NULL;
43911 }
43912
43913
43914 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43915 PyObject *resultobj = 0;
43916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43917 wxString *result = 0 ;
43918 void *argp1 = 0 ;
43919 int res1 = 0 ;
43920 PyObject *swig_obj[1] ;
43921
43922 if (!args) SWIG_fail;
43923 swig_obj[0] = args;
43924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43925 if (!SWIG_IsOK(res1)) {
43926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43927 }
43928 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 {
43932 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43933 result = (wxString *) &_result_ref;
43934 }
43935 wxPyEndAllowThreads(__tstate);
43936 if (PyErr_Occurred()) SWIG_fail;
43937 }
43938 {
43939 #if wxUSE_UNICODE
43940 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43941 #else
43942 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43943 #endif
43944 }
43945 return resultobj;
43946 fail:
43947 return NULL;
43948 }
43949
43950
43951 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43952 PyObject *resultobj = 0;
43953 wxString *arg1 = 0 ;
43954 wxString result;
43955 bool temp1 = false ;
43956 PyObject * obj0 = 0 ;
43957 char * kwnames[] = {
43958 (char *) "text", NULL
43959 };
43960
43961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43962 {
43963 arg1 = wxString_in_helper(obj0);
43964 if (arg1 == NULL) SWIG_fail;
43965 temp1 = true;
43966 }
43967 {
43968 PyThreadState* __tstate = wxPyBeginAllowThreads();
43969 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 {
43974 #if wxUSE_UNICODE
43975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43976 #else
43977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43978 #endif
43979 }
43980 {
43981 if (temp1)
43982 delete arg1;
43983 }
43984 return resultobj;
43985 fail:
43986 {
43987 if (temp1)
43988 delete arg1;
43989 }
43990 return NULL;
43991 }
43992
43993
43994 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43995 PyObject *resultobj = 0;
43996 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43997 wxItemKind result;
43998 void *argp1 = 0 ;
43999 int res1 = 0 ;
44000 PyObject *swig_obj[1] ;
44001
44002 if (!args) SWIG_fail;
44003 swig_obj[0] = args;
44004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44005 if (!SWIG_IsOK(res1)) {
44006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44007 }
44008 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44009 {
44010 PyThreadState* __tstate = wxPyBeginAllowThreads();
44011 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 resultobj = SWIG_From_int(static_cast< int >(result));
44016 return resultobj;
44017 fail:
44018 return NULL;
44019 }
44020
44021
44022 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44023 PyObject *resultobj = 0;
44024 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44025 wxItemKind arg2 ;
44026 void *argp1 = 0 ;
44027 int res1 = 0 ;
44028 int val2 ;
44029 int ecode2 = 0 ;
44030 PyObject * obj0 = 0 ;
44031 PyObject * obj1 = 0 ;
44032 char * kwnames[] = {
44033 (char *) "self",(char *) "kind", NULL
44034 };
44035
44036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44038 if (!SWIG_IsOK(res1)) {
44039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44040 }
44041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44042 ecode2 = SWIG_AsVal_int(obj1, &val2);
44043 if (!SWIG_IsOK(ecode2)) {
44044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44045 }
44046 arg2 = static_cast< wxItemKind >(val2);
44047 {
44048 PyThreadState* __tstate = wxPyBeginAllowThreads();
44049 (arg1)->SetKind(arg2);
44050 wxPyEndAllowThreads(__tstate);
44051 if (PyErr_Occurred()) SWIG_fail;
44052 }
44053 resultobj = SWIG_Py_Void();
44054 return resultobj;
44055 fail:
44056 return NULL;
44057 }
44058
44059
44060 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44061 PyObject *resultobj = 0;
44062 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44063 bool arg2 ;
44064 void *argp1 = 0 ;
44065 int res1 = 0 ;
44066 bool val2 ;
44067 int ecode2 = 0 ;
44068 PyObject * obj0 = 0 ;
44069 PyObject * obj1 = 0 ;
44070 char * kwnames[] = {
44071 (char *) "self",(char *) "checkable", NULL
44072 };
44073
44074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44076 if (!SWIG_IsOK(res1)) {
44077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44078 }
44079 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44081 if (!SWIG_IsOK(ecode2)) {
44082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44083 }
44084 arg2 = static_cast< bool >(val2);
44085 {
44086 PyThreadState* __tstate = wxPyBeginAllowThreads();
44087 (arg1)->SetCheckable(arg2);
44088 wxPyEndAllowThreads(__tstate);
44089 if (PyErr_Occurred()) SWIG_fail;
44090 }
44091 resultobj = SWIG_Py_Void();
44092 return resultobj;
44093 fail:
44094 return NULL;
44095 }
44096
44097
44098 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44099 PyObject *resultobj = 0;
44100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44101 bool result;
44102 void *argp1 = 0 ;
44103 int res1 = 0 ;
44104 PyObject *swig_obj[1] ;
44105
44106 if (!args) SWIG_fail;
44107 swig_obj[0] = args;
44108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44109 if (!SWIG_IsOK(res1)) {
44110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44111 }
44112 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44113 {
44114 PyThreadState* __tstate = wxPyBeginAllowThreads();
44115 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44116 wxPyEndAllowThreads(__tstate);
44117 if (PyErr_Occurred()) SWIG_fail;
44118 }
44119 {
44120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44121 }
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44129 PyObject *resultobj = 0;
44130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44131 bool result;
44132 void *argp1 = 0 ;
44133 int res1 = 0 ;
44134 PyObject *swig_obj[1] ;
44135
44136 if (!args) SWIG_fail;
44137 swig_obj[0] = args;
44138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44139 if (!SWIG_IsOK(res1)) {
44140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44141 }
44142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 {
44150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44151 }
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44159 PyObject *resultobj = 0;
44160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44161 wxMenu *arg2 = (wxMenu *) 0 ;
44162 void *argp1 = 0 ;
44163 int res1 = 0 ;
44164 void *argp2 = 0 ;
44165 int res2 = 0 ;
44166 PyObject * obj0 = 0 ;
44167 PyObject * obj1 = 0 ;
44168 char * kwnames[] = {
44169 (char *) "self",(char *) "menu", NULL
44170 };
44171
44172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44174 if (!SWIG_IsOK(res1)) {
44175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44176 }
44177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44179 if (!SWIG_IsOK(res2)) {
44180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44181 }
44182 arg2 = reinterpret_cast< wxMenu * >(argp2);
44183 {
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 (arg1)->SetSubMenu(arg2);
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = SWIG_Py_Void();
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44197 PyObject *resultobj = 0;
44198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44199 wxMenu *result = 0 ;
44200 void *argp1 = 0 ;
44201 int res1 = 0 ;
44202 PyObject *swig_obj[1] ;
44203
44204 if (!args) SWIG_fail;
44205 swig_obj[0] = args;
44206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44207 if (!SWIG_IsOK(res1)) {
44208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44209 }
44210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44211 {
44212 PyThreadState* __tstate = wxPyBeginAllowThreads();
44213 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44214 wxPyEndAllowThreads(__tstate);
44215 if (PyErr_Occurred()) SWIG_fail;
44216 }
44217 {
44218 resultobj = wxPyMake_wxObject(result, 0);
44219 }
44220 return resultobj;
44221 fail:
44222 return NULL;
44223 }
44224
44225
44226 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44227 PyObject *resultobj = 0;
44228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44229 bool arg2 = (bool) true ;
44230 void *argp1 = 0 ;
44231 int res1 = 0 ;
44232 bool val2 ;
44233 int ecode2 = 0 ;
44234 PyObject * obj0 = 0 ;
44235 PyObject * obj1 = 0 ;
44236 char * kwnames[] = {
44237 (char *) "self",(char *) "enable", NULL
44238 };
44239
44240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44242 if (!SWIG_IsOK(res1)) {
44243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44244 }
44245 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44246 if (obj1) {
44247 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44248 if (!SWIG_IsOK(ecode2)) {
44249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44250 }
44251 arg2 = static_cast< bool >(val2);
44252 }
44253 {
44254 PyThreadState* __tstate = wxPyBeginAllowThreads();
44255 (arg1)->Enable(arg2);
44256 wxPyEndAllowThreads(__tstate);
44257 if (PyErr_Occurred()) SWIG_fail;
44258 }
44259 resultobj = SWIG_Py_Void();
44260 return resultobj;
44261 fail:
44262 return NULL;
44263 }
44264
44265
44266 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44267 PyObject *resultobj = 0;
44268 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44269 bool result;
44270 void *argp1 = 0 ;
44271 int res1 = 0 ;
44272 PyObject *swig_obj[1] ;
44273
44274 if (!args) SWIG_fail;
44275 swig_obj[0] = args;
44276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44277 if (!SWIG_IsOK(res1)) {
44278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44279 }
44280 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44281 {
44282 PyThreadState* __tstate = wxPyBeginAllowThreads();
44283 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44284 wxPyEndAllowThreads(__tstate);
44285 if (PyErr_Occurred()) SWIG_fail;
44286 }
44287 {
44288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44289 }
44290 return resultobj;
44291 fail:
44292 return NULL;
44293 }
44294
44295
44296 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44297 PyObject *resultobj = 0;
44298 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44299 bool arg2 = (bool) true ;
44300 void *argp1 = 0 ;
44301 int res1 = 0 ;
44302 bool val2 ;
44303 int ecode2 = 0 ;
44304 PyObject * obj0 = 0 ;
44305 PyObject * obj1 = 0 ;
44306 char * kwnames[] = {
44307 (char *) "self",(char *) "check", NULL
44308 };
44309
44310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44312 if (!SWIG_IsOK(res1)) {
44313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44314 }
44315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44316 if (obj1) {
44317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44318 if (!SWIG_IsOK(ecode2)) {
44319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44320 }
44321 arg2 = static_cast< bool >(val2);
44322 }
44323 {
44324 PyThreadState* __tstate = wxPyBeginAllowThreads();
44325 (arg1)->Check(arg2);
44326 wxPyEndAllowThreads(__tstate);
44327 if (PyErr_Occurred()) SWIG_fail;
44328 }
44329 resultobj = SWIG_Py_Void();
44330 return resultobj;
44331 fail:
44332 return NULL;
44333 }
44334
44335
44336 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44337 PyObject *resultobj = 0;
44338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44339 bool result;
44340 void *argp1 = 0 ;
44341 int res1 = 0 ;
44342 PyObject *swig_obj[1] ;
44343
44344 if (!args) SWIG_fail;
44345 swig_obj[0] = args;
44346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44347 if (!SWIG_IsOK(res1)) {
44348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44349 }
44350 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44351 {
44352 PyThreadState* __tstate = wxPyBeginAllowThreads();
44353 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44354 wxPyEndAllowThreads(__tstate);
44355 if (PyErr_Occurred()) SWIG_fail;
44356 }
44357 {
44358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44359 }
44360 return resultobj;
44361 fail:
44362 return NULL;
44363 }
44364
44365
44366 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44367 PyObject *resultobj = 0;
44368 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 PyObject *swig_obj[1] ;
44372
44373 if (!args) SWIG_fail;
44374 swig_obj[0] = args;
44375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 (arg1)->Toggle();
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 resultobj = SWIG_Py_Void();
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44394 PyObject *resultobj = 0;
44395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44396 wxString *arg2 = 0 ;
44397 void *argp1 = 0 ;
44398 int res1 = 0 ;
44399 bool temp2 = false ;
44400 PyObject * obj0 = 0 ;
44401 PyObject * obj1 = 0 ;
44402 char * kwnames[] = {
44403 (char *) "self",(char *) "str", NULL
44404 };
44405
44406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44408 if (!SWIG_IsOK(res1)) {
44409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44410 }
44411 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44412 {
44413 arg2 = wxString_in_helper(obj1);
44414 if (arg2 == NULL) SWIG_fail;
44415 temp2 = true;
44416 }
44417 {
44418 PyThreadState* __tstate = wxPyBeginAllowThreads();
44419 (arg1)->SetHelp((wxString const &)*arg2);
44420 wxPyEndAllowThreads(__tstate);
44421 if (PyErr_Occurred()) SWIG_fail;
44422 }
44423 resultobj = SWIG_Py_Void();
44424 {
44425 if (temp2)
44426 delete arg2;
44427 }
44428 return resultobj;
44429 fail:
44430 {
44431 if (temp2)
44432 delete arg2;
44433 }
44434 return NULL;
44435 }
44436
44437
44438 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44439 PyObject *resultobj = 0;
44440 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44441 wxString *result = 0 ;
44442 void *argp1 = 0 ;
44443 int res1 = 0 ;
44444 PyObject *swig_obj[1] ;
44445
44446 if (!args) SWIG_fail;
44447 swig_obj[0] = args;
44448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44449 if (!SWIG_IsOK(res1)) {
44450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44451 }
44452 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44453 {
44454 PyThreadState* __tstate = wxPyBeginAllowThreads();
44455 {
44456 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44457 result = (wxString *) &_result_ref;
44458 }
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 {
44463 #if wxUSE_UNICODE
44464 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44465 #else
44466 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44467 #endif
44468 }
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44476 PyObject *resultobj = 0;
44477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44478 wxAcceleratorEntry *result = 0 ;
44479 void *argp1 = 0 ;
44480 int res1 = 0 ;
44481 PyObject *swig_obj[1] ;
44482
44483 if (!args) SWIG_fail;
44484 swig_obj[0] = args;
44485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44486 if (!SWIG_IsOK(res1)) {
44487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44488 }
44489 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44490 {
44491 PyThreadState* __tstate = wxPyBeginAllowThreads();
44492 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44493 wxPyEndAllowThreads(__tstate);
44494 if (PyErr_Occurred()) SWIG_fail;
44495 }
44496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44497 return resultobj;
44498 fail:
44499 return NULL;
44500 }
44501
44502
44503 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44504 PyObject *resultobj = 0;
44505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44506 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44507 void *argp1 = 0 ;
44508 int res1 = 0 ;
44509 void *argp2 = 0 ;
44510 int res2 = 0 ;
44511 PyObject * obj0 = 0 ;
44512 PyObject * obj1 = 0 ;
44513 char * kwnames[] = {
44514 (char *) "self",(char *) "accel", NULL
44515 };
44516
44517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44519 if (!SWIG_IsOK(res1)) {
44520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44521 }
44522 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44524 if (!SWIG_IsOK(res2)) {
44525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44526 }
44527 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 (arg1)->SetAccel(arg2);
44531 wxPyEndAllowThreads(__tstate);
44532 if (PyErr_Occurred()) SWIG_fail;
44533 }
44534 resultobj = SWIG_Py_Void();
44535 return resultobj;
44536 fail:
44537 return NULL;
44538 }
44539
44540
44541 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44542 PyObject *resultobj = 0;
44543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44544 wxBitmap *arg2 = 0 ;
44545 void *argp1 = 0 ;
44546 int res1 = 0 ;
44547 void *argp2 = 0 ;
44548 int res2 = 0 ;
44549 PyObject * obj0 = 0 ;
44550 PyObject * obj1 = 0 ;
44551 char * kwnames[] = {
44552 (char *) "self",(char *) "bitmap", NULL
44553 };
44554
44555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44557 if (!SWIG_IsOK(res1)) {
44558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44559 }
44560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44561 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44562 if (!SWIG_IsOK(res2)) {
44563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44564 }
44565 if (!argp2) {
44566 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44567 }
44568 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44569 {
44570 PyThreadState* __tstate = wxPyBeginAllowThreads();
44571 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44572 wxPyEndAllowThreads(__tstate);
44573 if (PyErr_Occurred()) SWIG_fail;
44574 }
44575 resultobj = SWIG_Py_Void();
44576 return resultobj;
44577 fail:
44578 return NULL;
44579 }
44580
44581
44582 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44583 PyObject *resultobj = 0;
44584 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44585 wxBitmap *result = 0 ;
44586 void *argp1 = 0 ;
44587 int res1 = 0 ;
44588 PyObject *swig_obj[1] ;
44589
44590 if (!args) SWIG_fail;
44591 swig_obj[0] = args;
44592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44593 if (!SWIG_IsOK(res1)) {
44594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44595 }
44596 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44597 {
44598 PyThreadState* __tstate = wxPyBeginAllowThreads();
44599 {
44600 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44601 result = (wxBitmap *) &_result_ref;
44602 }
44603 wxPyEndAllowThreads(__tstate);
44604 if (PyErr_Occurred()) SWIG_fail;
44605 }
44606 {
44607 wxBitmap* resultptr = new wxBitmap(*result);
44608 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44609 }
44610 return resultobj;
44611 fail:
44612 return NULL;
44613 }
44614
44615
44616 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44617 PyObject *resultobj = 0;
44618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44619 wxFont *arg2 = 0 ;
44620 void *argp1 = 0 ;
44621 int res1 = 0 ;
44622 void *argp2 = 0 ;
44623 int res2 = 0 ;
44624 PyObject * obj0 = 0 ;
44625 PyObject * obj1 = 0 ;
44626 char * kwnames[] = {
44627 (char *) "self",(char *) "font", NULL
44628 };
44629
44630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44632 if (!SWIG_IsOK(res1)) {
44633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44634 }
44635 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44637 if (!SWIG_IsOK(res2)) {
44638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44639 }
44640 if (!argp2) {
44641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44642 }
44643 arg2 = reinterpret_cast< wxFont * >(argp2);
44644 {
44645 PyThreadState* __tstate = wxPyBeginAllowThreads();
44646 (arg1)->SetFont((wxFont const &)*arg2);
44647 wxPyEndAllowThreads(__tstate);
44648 if (PyErr_Occurred()) SWIG_fail;
44649 }
44650 resultobj = SWIG_Py_Void();
44651 return resultobj;
44652 fail:
44653 return NULL;
44654 }
44655
44656
44657 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44658 PyObject *resultobj = 0;
44659 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44660 wxFont result;
44661 void *argp1 = 0 ;
44662 int res1 = 0 ;
44663 PyObject *swig_obj[1] ;
44664
44665 if (!args) SWIG_fail;
44666 swig_obj[0] = args;
44667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44668 if (!SWIG_IsOK(res1)) {
44669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44670 }
44671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44672 {
44673 PyThreadState* __tstate = wxPyBeginAllowThreads();
44674 result = (arg1)->GetFont();
44675 wxPyEndAllowThreads(__tstate);
44676 if (PyErr_Occurred()) SWIG_fail;
44677 }
44678 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44679 return resultobj;
44680 fail:
44681 return NULL;
44682 }
44683
44684
44685 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44686 PyObject *resultobj = 0;
44687 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44688 wxColour *arg2 = 0 ;
44689 void *argp1 = 0 ;
44690 int res1 = 0 ;
44691 wxColour temp2 ;
44692 PyObject * obj0 = 0 ;
44693 PyObject * obj1 = 0 ;
44694 char * kwnames[] = {
44695 (char *) "self",(char *) "colText", NULL
44696 };
44697
44698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44700 if (!SWIG_IsOK(res1)) {
44701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44702 }
44703 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44704 {
44705 arg2 = &temp2;
44706 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44707 }
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 (arg1)->SetTextColour((wxColour const &)*arg2);
44711 wxPyEndAllowThreads(__tstate);
44712 if (PyErr_Occurred()) SWIG_fail;
44713 }
44714 resultobj = SWIG_Py_Void();
44715 return resultobj;
44716 fail:
44717 return NULL;
44718 }
44719
44720
44721 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44722 PyObject *resultobj = 0;
44723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44724 wxColour result;
44725 void *argp1 = 0 ;
44726 int res1 = 0 ;
44727 PyObject *swig_obj[1] ;
44728
44729 if (!args) SWIG_fail;
44730 swig_obj[0] = args;
44731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44732 if (!SWIG_IsOK(res1)) {
44733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44734 }
44735 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44736 {
44737 PyThreadState* __tstate = wxPyBeginAllowThreads();
44738 result = (arg1)->GetTextColour();
44739 wxPyEndAllowThreads(__tstate);
44740 if (PyErr_Occurred()) SWIG_fail;
44741 }
44742 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44743 return resultobj;
44744 fail:
44745 return NULL;
44746 }
44747
44748
44749 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44750 PyObject *resultobj = 0;
44751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44752 wxColour *arg2 = 0 ;
44753 void *argp1 = 0 ;
44754 int res1 = 0 ;
44755 wxColour temp2 ;
44756 PyObject * obj0 = 0 ;
44757 PyObject * obj1 = 0 ;
44758 char * kwnames[] = {
44759 (char *) "self",(char *) "colBack", NULL
44760 };
44761
44762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44764 if (!SWIG_IsOK(res1)) {
44765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44766 }
44767 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44768 {
44769 arg2 = &temp2;
44770 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44771 }
44772 {
44773 PyThreadState* __tstate = wxPyBeginAllowThreads();
44774 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 resultobj = SWIG_Py_Void();
44779 return resultobj;
44780 fail:
44781 return NULL;
44782 }
44783
44784
44785 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44786 PyObject *resultobj = 0;
44787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44788 wxColour result;
44789 void *argp1 = 0 ;
44790 int res1 = 0 ;
44791 PyObject *swig_obj[1] ;
44792
44793 if (!args) SWIG_fail;
44794 swig_obj[0] = args;
44795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44798 }
44799 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44800 {
44801 PyThreadState* __tstate = wxPyBeginAllowThreads();
44802 result = (arg1)->GetBackgroundColour();
44803 wxPyEndAllowThreads(__tstate);
44804 if (PyErr_Occurred()) SWIG_fail;
44805 }
44806 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44807 return resultobj;
44808 fail:
44809 return NULL;
44810 }
44811
44812
44813 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44814 PyObject *resultobj = 0;
44815 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44816 wxBitmap *arg2 = 0 ;
44817 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44818 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44819 void *argp1 = 0 ;
44820 int res1 = 0 ;
44821 void *argp2 = 0 ;
44822 int res2 = 0 ;
44823 void *argp3 = 0 ;
44824 int res3 = 0 ;
44825 PyObject * obj0 = 0 ;
44826 PyObject * obj1 = 0 ;
44827 PyObject * obj2 = 0 ;
44828 char * kwnames[] = {
44829 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44830 };
44831
44832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44834 if (!SWIG_IsOK(res1)) {
44835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44836 }
44837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44839 if (!SWIG_IsOK(res2)) {
44840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44841 }
44842 if (!argp2) {
44843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44844 }
44845 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44846 if (obj2) {
44847 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44848 if (!SWIG_IsOK(res3)) {
44849 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44850 }
44851 if (!argp3) {
44852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44853 }
44854 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44855 }
44856 {
44857 PyThreadState* __tstate = wxPyBeginAllowThreads();
44858 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44859 wxPyEndAllowThreads(__tstate);
44860 if (PyErr_Occurred()) SWIG_fail;
44861 }
44862 resultobj = SWIG_Py_Void();
44863 return resultobj;
44864 fail:
44865 return NULL;
44866 }
44867
44868
44869 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44870 PyObject *resultobj = 0;
44871 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44872 wxBitmap *arg2 = 0 ;
44873 void *argp1 = 0 ;
44874 int res1 = 0 ;
44875 void *argp2 = 0 ;
44876 int res2 = 0 ;
44877 PyObject * obj0 = 0 ;
44878 PyObject * obj1 = 0 ;
44879 char * kwnames[] = {
44880 (char *) "self",(char *) "bmpDisabled", NULL
44881 };
44882
44883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44885 if (!SWIG_IsOK(res1)) {
44886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44887 }
44888 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44890 if (!SWIG_IsOK(res2)) {
44891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44892 }
44893 if (!argp2) {
44894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44895 }
44896 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44897 {
44898 PyThreadState* __tstate = wxPyBeginAllowThreads();
44899 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44900 wxPyEndAllowThreads(__tstate);
44901 if (PyErr_Occurred()) SWIG_fail;
44902 }
44903 resultobj = SWIG_Py_Void();
44904 return resultobj;
44905 fail:
44906 return NULL;
44907 }
44908
44909
44910 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44911 PyObject *resultobj = 0;
44912 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44913 wxBitmap *result = 0 ;
44914 void *argp1 = 0 ;
44915 int res1 = 0 ;
44916 PyObject *swig_obj[1] ;
44917
44918 if (!args) SWIG_fail;
44919 swig_obj[0] = args;
44920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44921 if (!SWIG_IsOK(res1)) {
44922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44923 }
44924 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44925 {
44926 PyThreadState* __tstate = wxPyBeginAllowThreads();
44927 {
44928 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44929 result = (wxBitmap *) &_result_ref;
44930 }
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 {
44935 wxBitmap* resultptr = new wxBitmap(*result);
44936 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44937 }
44938 return resultobj;
44939 fail:
44940 return NULL;
44941 }
44942
44943
44944 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44945 PyObject *resultobj = 0;
44946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44947 int arg2 ;
44948 void *argp1 = 0 ;
44949 int res1 = 0 ;
44950 int val2 ;
44951 int ecode2 = 0 ;
44952 PyObject * obj0 = 0 ;
44953 PyObject * obj1 = 0 ;
44954 char * kwnames[] = {
44955 (char *) "self",(char *) "nWidth", NULL
44956 };
44957
44958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44960 if (!SWIG_IsOK(res1)) {
44961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44962 }
44963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44964 ecode2 = SWIG_AsVal_int(obj1, &val2);
44965 if (!SWIG_IsOK(ecode2)) {
44966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44967 }
44968 arg2 = static_cast< int >(val2);
44969 {
44970 PyThreadState* __tstate = wxPyBeginAllowThreads();
44971 (arg1)->SetMarginWidth(arg2);
44972 wxPyEndAllowThreads(__tstate);
44973 if (PyErr_Occurred()) SWIG_fail;
44974 }
44975 resultobj = SWIG_Py_Void();
44976 return resultobj;
44977 fail:
44978 return NULL;
44979 }
44980
44981
44982 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44983 PyObject *resultobj = 0;
44984 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44985 int result;
44986 void *argp1 = 0 ;
44987 int res1 = 0 ;
44988 PyObject *swig_obj[1] ;
44989
44990 if (!args) SWIG_fail;
44991 swig_obj[0] = args;
44992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44993 if (!SWIG_IsOK(res1)) {
44994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44995 }
44996 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44997 {
44998 PyThreadState* __tstate = wxPyBeginAllowThreads();
44999 result = (int)(arg1)->GetMarginWidth();
45000 wxPyEndAllowThreads(__tstate);
45001 if (PyErr_Occurred()) SWIG_fail;
45002 }
45003 resultobj = SWIG_From_int(static_cast< int >(result));
45004 return resultobj;
45005 fail:
45006 return NULL;
45007 }
45008
45009
45010 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45011 PyObject *resultobj = 0;
45012 int result;
45013
45014 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
45015 {
45016 PyThreadState* __tstate = wxPyBeginAllowThreads();
45017 result = (int)wxMenuItem::GetDefaultMarginWidth();
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 resultobj = SWIG_From_int(static_cast< int >(result));
45022 return resultobj;
45023 fail:
45024 return NULL;
45025 }
45026
45027
45028 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45029 PyObject *resultobj = 0;
45030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45031 bool result;
45032 void *argp1 = 0 ;
45033 int res1 = 0 ;
45034 PyObject *swig_obj[1] ;
45035
45036 if (!args) SWIG_fail;
45037 swig_obj[0] = args;
45038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45039 if (!SWIG_IsOK(res1)) {
45040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45041 }
45042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45043 {
45044 PyThreadState* __tstate = wxPyBeginAllowThreads();
45045 result = (bool)(arg1)->IsOwnerDrawn();
45046 wxPyEndAllowThreads(__tstate);
45047 if (PyErr_Occurred()) SWIG_fail;
45048 }
45049 {
45050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45051 }
45052 return resultobj;
45053 fail:
45054 return NULL;
45055 }
45056
45057
45058 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45059 PyObject *resultobj = 0;
45060 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45061 bool arg2 = (bool) true ;
45062 void *argp1 = 0 ;
45063 int res1 = 0 ;
45064 bool val2 ;
45065 int ecode2 = 0 ;
45066 PyObject * obj0 = 0 ;
45067 PyObject * obj1 = 0 ;
45068 char * kwnames[] = {
45069 (char *) "self",(char *) "ownerDrawn", NULL
45070 };
45071
45072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45074 if (!SWIG_IsOK(res1)) {
45075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45076 }
45077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45078 if (obj1) {
45079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45080 if (!SWIG_IsOK(ecode2)) {
45081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45082 }
45083 arg2 = static_cast< bool >(val2);
45084 }
45085 {
45086 PyThreadState* __tstate = wxPyBeginAllowThreads();
45087 (arg1)->SetOwnerDrawn(arg2);
45088 wxPyEndAllowThreads(__tstate);
45089 if (PyErr_Occurred()) SWIG_fail;
45090 }
45091 resultobj = SWIG_Py_Void();
45092 return resultobj;
45093 fail:
45094 return NULL;
45095 }
45096
45097
45098 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45099 PyObject *resultobj = 0;
45100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45101 void *argp1 = 0 ;
45102 int res1 = 0 ;
45103 PyObject *swig_obj[1] ;
45104
45105 if (!args) SWIG_fail;
45106 swig_obj[0] = args;
45107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45108 if (!SWIG_IsOK(res1)) {
45109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45110 }
45111 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45112 {
45113 PyThreadState* __tstate = wxPyBeginAllowThreads();
45114 (arg1)->ResetOwnerDrawn();
45115 wxPyEndAllowThreads(__tstate);
45116 if (PyErr_Occurred()) SWIG_fail;
45117 }
45118 resultobj = SWIG_Py_Void();
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45126 PyObject *obj;
45127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45128 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45129 return SWIG_Py_Void();
45130 }
45131
45132 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45133 return SWIG_Python_InitShadowInstance(args);
45134 }
45135
45136 SWIGINTERN int ControlNameStr_set(PyObject *) {
45137 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45138 return 1;
45139 }
45140
45141
45142 SWIGINTERN PyObject *ControlNameStr_get(void) {
45143 PyObject *pyobj = 0;
45144
45145 {
45146 #if wxUSE_UNICODE
45147 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45148 #else
45149 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45150 #endif
45151 }
45152 return pyobj;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxWindow *arg1 = (wxWindow *) 0 ;
45159 int arg2 = (int) -1 ;
45160 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45161 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45162 wxSize const &arg4_defvalue = wxDefaultSize ;
45163 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45164 long arg5 = (long) 0 ;
45165 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45166 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45167 wxString const &arg7_defvalue = wxPyControlNameStr ;
45168 wxString *arg7 = (wxString *) &arg7_defvalue ;
45169 wxControl *result = 0 ;
45170 void *argp1 = 0 ;
45171 int res1 = 0 ;
45172 int val2 ;
45173 int ecode2 = 0 ;
45174 wxPoint temp3 ;
45175 wxSize temp4 ;
45176 long val5 ;
45177 int ecode5 = 0 ;
45178 void *argp6 = 0 ;
45179 int res6 = 0 ;
45180 bool temp7 = false ;
45181 PyObject * obj0 = 0 ;
45182 PyObject * obj1 = 0 ;
45183 PyObject * obj2 = 0 ;
45184 PyObject * obj3 = 0 ;
45185 PyObject * obj4 = 0 ;
45186 PyObject * obj5 = 0 ;
45187 PyObject * obj6 = 0 ;
45188 char * kwnames[] = {
45189 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45190 };
45191
45192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45194 if (!SWIG_IsOK(res1)) {
45195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45196 }
45197 arg1 = reinterpret_cast< wxWindow * >(argp1);
45198 if (obj1) {
45199 ecode2 = SWIG_AsVal_int(obj1, &val2);
45200 if (!SWIG_IsOK(ecode2)) {
45201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45202 }
45203 arg2 = static_cast< int >(val2);
45204 }
45205 if (obj2) {
45206 {
45207 arg3 = &temp3;
45208 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45209 }
45210 }
45211 if (obj3) {
45212 {
45213 arg4 = &temp4;
45214 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45215 }
45216 }
45217 if (obj4) {
45218 ecode5 = SWIG_AsVal_long(obj4, &val5);
45219 if (!SWIG_IsOK(ecode5)) {
45220 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45221 }
45222 arg5 = static_cast< long >(val5);
45223 }
45224 if (obj5) {
45225 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45226 if (!SWIG_IsOK(res6)) {
45227 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45228 }
45229 if (!argp6) {
45230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45231 }
45232 arg6 = reinterpret_cast< wxValidator * >(argp6);
45233 }
45234 if (obj6) {
45235 {
45236 arg7 = wxString_in_helper(obj6);
45237 if (arg7 == NULL) SWIG_fail;
45238 temp7 = true;
45239 }
45240 }
45241 {
45242 if (!wxPyCheckForApp()) SWIG_fail;
45243 PyThreadState* __tstate = wxPyBeginAllowThreads();
45244 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45249 {
45250 if (temp7)
45251 delete arg7;
45252 }
45253 return resultobj;
45254 fail:
45255 {
45256 if (temp7)
45257 delete arg7;
45258 }
45259 return NULL;
45260 }
45261
45262
45263 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45264 PyObject *resultobj = 0;
45265 wxControl *result = 0 ;
45266
45267 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45268 {
45269 if (!wxPyCheckForApp()) SWIG_fail;
45270 PyThreadState* __tstate = wxPyBeginAllowThreads();
45271 result = (wxControl *)new wxControl();
45272 wxPyEndAllowThreads(__tstate);
45273 if (PyErr_Occurred()) SWIG_fail;
45274 }
45275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45276 return resultobj;
45277 fail:
45278 return NULL;
45279 }
45280
45281
45282 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45283 PyObject *resultobj = 0;
45284 wxControl *arg1 = (wxControl *) 0 ;
45285 wxWindow *arg2 = (wxWindow *) 0 ;
45286 int arg3 = (int) -1 ;
45287 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45288 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45289 wxSize const &arg5_defvalue = wxDefaultSize ;
45290 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45291 long arg6 = (long) 0 ;
45292 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45293 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45294 wxString const &arg8_defvalue = wxPyControlNameStr ;
45295 wxString *arg8 = (wxString *) &arg8_defvalue ;
45296 bool result;
45297 void *argp1 = 0 ;
45298 int res1 = 0 ;
45299 void *argp2 = 0 ;
45300 int res2 = 0 ;
45301 int val3 ;
45302 int ecode3 = 0 ;
45303 wxPoint temp4 ;
45304 wxSize temp5 ;
45305 long val6 ;
45306 int ecode6 = 0 ;
45307 void *argp7 = 0 ;
45308 int res7 = 0 ;
45309 bool temp8 = false ;
45310 PyObject * obj0 = 0 ;
45311 PyObject * obj1 = 0 ;
45312 PyObject * obj2 = 0 ;
45313 PyObject * obj3 = 0 ;
45314 PyObject * obj4 = 0 ;
45315 PyObject * obj5 = 0 ;
45316 PyObject * obj6 = 0 ;
45317 PyObject * obj7 = 0 ;
45318 char * kwnames[] = {
45319 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45320 };
45321
45322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45324 if (!SWIG_IsOK(res1)) {
45325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45326 }
45327 arg1 = reinterpret_cast< wxControl * >(argp1);
45328 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45329 if (!SWIG_IsOK(res2)) {
45330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45331 }
45332 arg2 = reinterpret_cast< wxWindow * >(argp2);
45333 if (obj2) {
45334 ecode3 = SWIG_AsVal_int(obj2, &val3);
45335 if (!SWIG_IsOK(ecode3)) {
45336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45337 }
45338 arg3 = static_cast< int >(val3);
45339 }
45340 if (obj3) {
45341 {
45342 arg4 = &temp4;
45343 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45344 }
45345 }
45346 if (obj4) {
45347 {
45348 arg5 = &temp5;
45349 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45350 }
45351 }
45352 if (obj5) {
45353 ecode6 = SWIG_AsVal_long(obj5, &val6);
45354 if (!SWIG_IsOK(ecode6)) {
45355 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45356 }
45357 arg6 = static_cast< long >(val6);
45358 }
45359 if (obj6) {
45360 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45361 if (!SWIG_IsOK(res7)) {
45362 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45363 }
45364 if (!argp7) {
45365 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45366 }
45367 arg7 = reinterpret_cast< wxValidator * >(argp7);
45368 }
45369 if (obj7) {
45370 {
45371 arg8 = wxString_in_helper(obj7);
45372 if (arg8 == NULL) SWIG_fail;
45373 temp8 = true;
45374 }
45375 }
45376 {
45377 PyThreadState* __tstate = wxPyBeginAllowThreads();
45378 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45379 wxPyEndAllowThreads(__tstate);
45380 if (PyErr_Occurred()) SWIG_fail;
45381 }
45382 {
45383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45384 }
45385 {
45386 if (temp8)
45387 delete arg8;
45388 }
45389 return resultobj;
45390 fail:
45391 {
45392 if (temp8)
45393 delete arg8;
45394 }
45395 return NULL;
45396 }
45397
45398
45399 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45400 PyObject *resultobj = 0;
45401 wxControl *arg1 = (wxControl *) 0 ;
45402 int result;
45403 void *argp1 = 0 ;
45404 int res1 = 0 ;
45405 PyObject *swig_obj[1] ;
45406
45407 if (!args) SWIG_fail;
45408 swig_obj[0] = args;
45409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45410 if (!SWIG_IsOK(res1)) {
45411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45412 }
45413 arg1 = reinterpret_cast< wxControl * >(argp1);
45414 {
45415 PyThreadState* __tstate = wxPyBeginAllowThreads();
45416 result = (int)((wxControl const *)arg1)->GetAlignment();
45417 wxPyEndAllowThreads(__tstate);
45418 if (PyErr_Occurred()) SWIG_fail;
45419 }
45420 resultobj = SWIG_From_int(static_cast< int >(result));
45421 return resultobj;
45422 fail:
45423 return NULL;
45424 }
45425
45426
45427 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45428 PyObject *resultobj = 0;
45429 wxControl *arg1 = (wxControl *) 0 ;
45430 wxString result;
45431 void *argp1 = 0 ;
45432 int res1 = 0 ;
45433 PyObject *swig_obj[1] ;
45434
45435 if (!args) SWIG_fail;
45436 swig_obj[0] = args;
45437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45438 if (!SWIG_IsOK(res1)) {
45439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45440 }
45441 arg1 = reinterpret_cast< wxControl * >(argp1);
45442 {
45443 PyThreadState* __tstate = wxPyBeginAllowThreads();
45444 result = ((wxControl const *)arg1)->GetLabelText();
45445 wxPyEndAllowThreads(__tstate);
45446 if (PyErr_Occurred()) SWIG_fail;
45447 }
45448 {
45449 #if wxUSE_UNICODE
45450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45451 #else
45452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45453 #endif
45454 }
45455 return resultobj;
45456 fail:
45457 return NULL;
45458 }
45459
45460
45461 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45462 PyObject *resultobj = 0;
45463 wxControl *arg1 = (wxControl *) 0 ;
45464 wxCommandEvent *arg2 = 0 ;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 void *argp2 = 0 ;
45468 int res2 = 0 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "event", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45479 }
45480 arg1 = reinterpret_cast< wxControl * >(argp1);
45481 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45482 if (!SWIG_IsOK(res2)) {
45483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45484 }
45485 if (!argp2) {
45486 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45487 }
45488 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45489 {
45490 PyThreadState* __tstate = wxPyBeginAllowThreads();
45491 (arg1)->Command(*arg2);
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 resultobj = SWIG_Py_Void();
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45503 PyObject *resultobj = 0;
45504 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45505 SwigValueWrapper<wxVisualAttributes > result;
45506 int val1 ;
45507 int ecode1 = 0 ;
45508 PyObject * obj0 = 0 ;
45509 char * kwnames[] = {
45510 (char *) "variant", NULL
45511 };
45512
45513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45514 if (obj0) {
45515 ecode1 = SWIG_AsVal_int(obj0, &val1);
45516 if (!SWIG_IsOK(ecode1)) {
45517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45518 }
45519 arg1 = static_cast< wxWindowVariant >(val1);
45520 }
45521 {
45522 if (!wxPyCheckForApp()) SWIG_fail;
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 result = wxControl::GetClassDefaultAttributes(arg1);
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45529 return resultobj;
45530 fail:
45531 return NULL;
45532 }
45533
45534
45535 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45536 PyObject *obj;
45537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45538 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45539 return SWIG_Py_Void();
45540 }
45541
45542 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45543 return SWIG_Python_InitShadowInstance(args);
45544 }
45545
45546 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45547 PyObject *resultobj = 0;
45548 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45549 wxString *arg2 = 0 ;
45550 PyObject *arg3 = (PyObject *) NULL ;
45551 int result;
45552 void *argp1 = 0 ;
45553 int res1 = 0 ;
45554 bool temp2 = false ;
45555 PyObject * obj0 = 0 ;
45556 PyObject * obj1 = 0 ;
45557 PyObject * obj2 = 0 ;
45558 char * kwnames[] = {
45559 (char *) "self",(char *) "item",(char *) "clientData", NULL
45560 };
45561
45562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45564 if (!SWIG_IsOK(res1)) {
45565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45566 }
45567 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45568 {
45569 arg2 = wxString_in_helper(obj1);
45570 if (arg2 == NULL) SWIG_fail;
45571 temp2 = true;
45572 }
45573 if (obj2) {
45574 arg3 = obj2;
45575 }
45576 {
45577 PyThreadState* __tstate = wxPyBeginAllowThreads();
45578 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45579 wxPyEndAllowThreads(__tstate);
45580 if (PyErr_Occurred()) SWIG_fail;
45581 }
45582 resultobj = SWIG_From_int(static_cast< int >(result));
45583 {
45584 if (temp2)
45585 delete arg2;
45586 }
45587 return resultobj;
45588 fail:
45589 {
45590 if (temp2)
45591 delete arg2;
45592 }
45593 return NULL;
45594 }
45595
45596
45597 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45598 PyObject *resultobj = 0;
45599 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45600 wxArrayString *arg2 = 0 ;
45601 void *argp1 = 0 ;
45602 int res1 = 0 ;
45603 bool temp2 = false ;
45604 PyObject * obj0 = 0 ;
45605 PyObject * obj1 = 0 ;
45606 char * kwnames[] = {
45607 (char *) "self",(char *) "strings", NULL
45608 };
45609
45610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45612 if (!SWIG_IsOK(res1)) {
45613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45614 }
45615 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45616 {
45617 if (! PySequence_Check(obj1)) {
45618 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45619 SWIG_fail;
45620 }
45621 arg2 = new wxArrayString;
45622 temp2 = true;
45623 int i, len=PySequence_Length(obj1);
45624 for (i=0; i<len; i++) {
45625 PyObject* item = PySequence_GetItem(obj1, i);
45626 wxString* s = wxString_in_helper(item);
45627 if (PyErr_Occurred()) SWIG_fail;
45628 arg2->Add(*s);
45629 delete s;
45630 Py_DECREF(item);
45631 }
45632 }
45633 {
45634 PyThreadState* __tstate = wxPyBeginAllowThreads();
45635 (arg1)->Append((wxArrayString const &)*arg2);
45636 wxPyEndAllowThreads(__tstate);
45637 if (PyErr_Occurred()) SWIG_fail;
45638 }
45639 resultobj = SWIG_Py_Void();
45640 {
45641 if (temp2) delete arg2;
45642 }
45643 return resultobj;
45644 fail:
45645 {
45646 if (temp2) delete arg2;
45647 }
45648 return NULL;
45649 }
45650
45651
45652 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45653 PyObject *resultobj = 0;
45654 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45655 wxString *arg2 = 0 ;
45656 unsigned int arg3 ;
45657 PyObject *arg4 = (PyObject *) NULL ;
45658 int result;
45659 void *argp1 = 0 ;
45660 int res1 = 0 ;
45661 bool temp2 = false ;
45662 unsigned int val3 ;
45663 int ecode3 = 0 ;
45664 PyObject * obj0 = 0 ;
45665 PyObject * obj1 = 0 ;
45666 PyObject * obj2 = 0 ;
45667 PyObject * obj3 = 0 ;
45668 char * kwnames[] = {
45669 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45670 };
45671
45672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45674 if (!SWIG_IsOK(res1)) {
45675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45676 }
45677 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45678 {
45679 arg2 = wxString_in_helper(obj1);
45680 if (arg2 == NULL) SWIG_fail;
45681 temp2 = true;
45682 }
45683 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45684 if (!SWIG_IsOK(ecode3)) {
45685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45686 }
45687 arg3 = static_cast< unsigned int >(val3);
45688 if (obj3) {
45689 arg4 = obj3;
45690 }
45691 {
45692 PyThreadState* __tstate = wxPyBeginAllowThreads();
45693 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45694 wxPyEndAllowThreads(__tstate);
45695 if (PyErr_Occurred()) SWIG_fail;
45696 }
45697 resultobj = SWIG_From_int(static_cast< int >(result));
45698 {
45699 if (temp2)
45700 delete arg2;
45701 }
45702 return resultobj;
45703 fail:
45704 {
45705 if (temp2)
45706 delete arg2;
45707 }
45708 return NULL;
45709 }
45710
45711
45712 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45713 PyObject *resultobj = 0;
45714 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45715 void *argp1 = 0 ;
45716 int res1 = 0 ;
45717 PyObject *swig_obj[1] ;
45718
45719 if (!args) SWIG_fail;
45720 swig_obj[0] = args;
45721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45722 if (!SWIG_IsOK(res1)) {
45723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45724 }
45725 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 (arg1)->Clear();
45729 wxPyEndAllowThreads(__tstate);
45730 if (PyErr_Occurred()) SWIG_fail;
45731 }
45732 resultobj = SWIG_Py_Void();
45733 return resultobj;
45734 fail:
45735 return NULL;
45736 }
45737
45738
45739 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45740 PyObject *resultobj = 0;
45741 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45742 unsigned int arg2 ;
45743 void *argp1 = 0 ;
45744 int res1 = 0 ;
45745 unsigned int val2 ;
45746 int ecode2 = 0 ;
45747 PyObject * obj0 = 0 ;
45748 PyObject * obj1 = 0 ;
45749 char * kwnames[] = {
45750 (char *) "self",(char *) "n", NULL
45751 };
45752
45753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45755 if (!SWIG_IsOK(res1)) {
45756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45757 }
45758 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45759 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45760 if (!SWIG_IsOK(ecode2)) {
45761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45762 }
45763 arg2 = static_cast< unsigned int >(val2);
45764 {
45765 PyThreadState* __tstate = wxPyBeginAllowThreads();
45766 (arg1)->Delete(arg2);
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 resultobj = SWIG_Py_Void();
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45778 PyObject *resultobj = 0;
45779 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45780 unsigned int arg2 ;
45781 PyObject *result = 0 ;
45782 void *argp1 = 0 ;
45783 int res1 = 0 ;
45784 unsigned int val2 ;
45785 int ecode2 = 0 ;
45786 PyObject * obj0 = 0 ;
45787 PyObject * obj1 = 0 ;
45788 char * kwnames[] = {
45789 (char *) "self",(char *) "n", NULL
45790 };
45791
45792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45796 }
45797 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45798 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45799 if (!SWIG_IsOK(ecode2)) {
45800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45801 }
45802 arg2 = static_cast< unsigned int >(val2);
45803 {
45804 PyThreadState* __tstate = wxPyBeginAllowThreads();
45805 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45806 wxPyEndAllowThreads(__tstate);
45807 if (PyErr_Occurred()) SWIG_fail;
45808 }
45809 resultobj = result;
45810 return resultobj;
45811 fail:
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45817 PyObject *resultobj = 0;
45818 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45819 unsigned int arg2 ;
45820 PyObject *arg3 = (PyObject *) 0 ;
45821 void *argp1 = 0 ;
45822 int res1 = 0 ;
45823 unsigned int val2 ;
45824 int ecode2 = 0 ;
45825 PyObject * obj0 = 0 ;
45826 PyObject * obj1 = 0 ;
45827 PyObject * obj2 = 0 ;
45828 char * kwnames[] = {
45829 (char *) "self",(char *) "n",(char *) "clientData", NULL
45830 };
45831
45832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45834 if (!SWIG_IsOK(res1)) {
45835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45836 }
45837 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45838 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45839 if (!SWIG_IsOK(ecode2)) {
45840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45841 }
45842 arg2 = static_cast< unsigned int >(val2);
45843 arg3 = obj2;
45844 {
45845 PyThreadState* __tstate = wxPyBeginAllowThreads();
45846 wxItemContainer_SetClientData(arg1,arg2,arg3);
45847 wxPyEndAllowThreads(__tstate);
45848 if (PyErr_Occurred()) SWIG_fail;
45849 }
45850 resultobj = SWIG_Py_Void();
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45858 PyObject *resultobj = 0;
45859 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45860 unsigned int result;
45861 void *argp1 = 0 ;
45862 int res1 = 0 ;
45863 PyObject *swig_obj[1] ;
45864
45865 if (!args) SWIG_fail;
45866 swig_obj[0] = args;
45867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45868 if (!SWIG_IsOK(res1)) {
45869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45870 }
45871 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45872 {
45873 PyThreadState* __tstate = wxPyBeginAllowThreads();
45874 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45875 wxPyEndAllowThreads(__tstate);
45876 if (PyErr_Occurred()) SWIG_fail;
45877 }
45878 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45879 return resultobj;
45880 fail:
45881 return NULL;
45882 }
45883
45884
45885 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45886 PyObject *resultobj = 0;
45887 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45888 bool result;
45889 void *argp1 = 0 ;
45890 int res1 = 0 ;
45891 PyObject *swig_obj[1] ;
45892
45893 if (!args) SWIG_fail;
45894 swig_obj[0] = args;
45895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45896 if (!SWIG_IsOK(res1)) {
45897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45898 }
45899 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45900 {
45901 PyThreadState* __tstate = wxPyBeginAllowThreads();
45902 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 {
45907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45908 }
45909 return resultobj;
45910 fail:
45911 return NULL;
45912 }
45913
45914
45915 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45916 PyObject *resultobj = 0;
45917 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45918 unsigned int arg2 ;
45919 wxString result;
45920 void *argp1 = 0 ;
45921 int res1 = 0 ;
45922 unsigned int val2 ;
45923 int ecode2 = 0 ;
45924 PyObject * obj0 = 0 ;
45925 PyObject * obj1 = 0 ;
45926 char * kwnames[] = {
45927 (char *) "self",(char *) "n", NULL
45928 };
45929
45930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45932 if (!SWIG_IsOK(res1)) {
45933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45934 }
45935 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45936 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45937 if (!SWIG_IsOK(ecode2)) {
45938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45939 }
45940 arg2 = static_cast< unsigned int >(val2);
45941 {
45942 PyThreadState* __tstate = wxPyBeginAllowThreads();
45943 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45944 wxPyEndAllowThreads(__tstate);
45945 if (PyErr_Occurred()) SWIG_fail;
45946 }
45947 {
45948 #if wxUSE_UNICODE
45949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45950 #else
45951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45952 #endif
45953 }
45954 return resultobj;
45955 fail:
45956 return NULL;
45957 }
45958
45959
45960 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45961 PyObject *resultobj = 0;
45962 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45963 wxArrayString result;
45964 void *argp1 = 0 ;
45965 int res1 = 0 ;
45966 PyObject *swig_obj[1] ;
45967
45968 if (!args) SWIG_fail;
45969 swig_obj[0] = args;
45970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45971 if (!SWIG_IsOK(res1)) {
45972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45973 }
45974 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45975 {
45976 PyThreadState* __tstate = wxPyBeginAllowThreads();
45977 result = ((wxItemContainer const *)arg1)->GetStrings();
45978 wxPyEndAllowThreads(__tstate);
45979 if (PyErr_Occurred()) SWIG_fail;
45980 }
45981 {
45982 resultobj = wxArrayString2PyList_helper(result);
45983 }
45984 return resultobj;
45985 fail:
45986 return NULL;
45987 }
45988
45989
45990 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45991 PyObject *resultobj = 0;
45992 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45993 unsigned int arg2 ;
45994 wxString *arg3 = 0 ;
45995 void *argp1 = 0 ;
45996 int res1 = 0 ;
45997 unsigned int val2 ;
45998 int ecode2 = 0 ;
45999 bool temp3 = false ;
46000 PyObject * obj0 = 0 ;
46001 PyObject * obj1 = 0 ;
46002 PyObject * obj2 = 0 ;
46003 char * kwnames[] = {
46004 (char *) "self",(char *) "n",(char *) "s", NULL
46005 };
46006
46007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46009 if (!SWIG_IsOK(res1)) {
46010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46011 }
46012 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46013 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
46014 if (!SWIG_IsOK(ecode2)) {
46015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
46016 }
46017 arg2 = static_cast< unsigned int >(val2);
46018 {
46019 arg3 = wxString_in_helper(obj2);
46020 if (arg3 == NULL) SWIG_fail;
46021 temp3 = true;
46022 }
46023 {
46024 PyThreadState* __tstate = wxPyBeginAllowThreads();
46025 (arg1)->SetString(arg2,(wxString const &)*arg3);
46026 wxPyEndAllowThreads(__tstate);
46027 if (PyErr_Occurred()) SWIG_fail;
46028 }
46029 resultobj = SWIG_Py_Void();
46030 {
46031 if (temp3)
46032 delete arg3;
46033 }
46034 return resultobj;
46035 fail:
46036 {
46037 if (temp3)
46038 delete arg3;
46039 }
46040 return NULL;
46041 }
46042
46043
46044 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46045 PyObject *resultobj = 0;
46046 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46047 wxString *arg2 = 0 ;
46048 int result;
46049 void *argp1 = 0 ;
46050 int res1 = 0 ;
46051 bool temp2 = false ;
46052 PyObject * obj0 = 0 ;
46053 PyObject * obj1 = 0 ;
46054 char * kwnames[] = {
46055 (char *) "self",(char *) "s", NULL
46056 };
46057
46058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46060 if (!SWIG_IsOK(res1)) {
46061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46062 }
46063 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46064 {
46065 arg2 = wxString_in_helper(obj1);
46066 if (arg2 == NULL) SWIG_fail;
46067 temp2 = true;
46068 }
46069 {
46070 PyThreadState* __tstate = wxPyBeginAllowThreads();
46071 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46072 wxPyEndAllowThreads(__tstate);
46073 if (PyErr_Occurred()) SWIG_fail;
46074 }
46075 resultobj = SWIG_From_int(static_cast< int >(result));
46076 {
46077 if (temp2)
46078 delete arg2;
46079 }
46080 return resultobj;
46081 fail:
46082 {
46083 if (temp2)
46084 delete arg2;
46085 }
46086 return NULL;
46087 }
46088
46089
46090 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46091 PyObject *resultobj = 0;
46092 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46093 int arg2 ;
46094 void *argp1 = 0 ;
46095 int res1 = 0 ;
46096 int val2 ;
46097 int ecode2 = 0 ;
46098 PyObject * obj0 = 0 ;
46099 PyObject * obj1 = 0 ;
46100 char * kwnames[] = {
46101 (char *) "self",(char *) "n", NULL
46102 };
46103
46104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46106 if (!SWIG_IsOK(res1)) {
46107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46108 }
46109 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46110 ecode2 = SWIG_AsVal_int(obj1, &val2);
46111 if (!SWIG_IsOK(ecode2)) {
46112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46113 }
46114 arg2 = static_cast< int >(val2);
46115 {
46116 PyThreadState* __tstate = wxPyBeginAllowThreads();
46117 (arg1)->SetSelection(arg2);
46118 wxPyEndAllowThreads(__tstate);
46119 if (PyErr_Occurred()) SWIG_fail;
46120 }
46121 resultobj = SWIG_Py_Void();
46122 return resultobj;
46123 fail:
46124 return NULL;
46125 }
46126
46127
46128 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46129 PyObject *resultobj = 0;
46130 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46131 int result;
46132 void *argp1 = 0 ;
46133 int res1 = 0 ;
46134 PyObject *swig_obj[1] ;
46135
46136 if (!args) SWIG_fail;
46137 swig_obj[0] = args;
46138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46139 if (!SWIG_IsOK(res1)) {
46140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46141 }
46142 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46143 {
46144 PyThreadState* __tstate = wxPyBeginAllowThreads();
46145 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46146 wxPyEndAllowThreads(__tstate);
46147 if (PyErr_Occurred()) SWIG_fail;
46148 }
46149 resultobj = SWIG_From_int(static_cast< int >(result));
46150 return resultobj;
46151 fail:
46152 return NULL;
46153 }
46154
46155
46156 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46157 PyObject *resultobj = 0;
46158 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46159 wxString *arg2 = 0 ;
46160 bool result;
46161 void *argp1 = 0 ;
46162 int res1 = 0 ;
46163 bool temp2 = false ;
46164 PyObject * obj0 = 0 ;
46165 PyObject * obj1 = 0 ;
46166 char * kwnames[] = {
46167 (char *) "self",(char *) "s", NULL
46168 };
46169
46170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46172 if (!SWIG_IsOK(res1)) {
46173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46174 }
46175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46176 {
46177 arg2 = wxString_in_helper(obj1);
46178 if (arg2 == NULL) SWIG_fail;
46179 temp2 = true;
46180 }
46181 {
46182 PyThreadState* __tstate = wxPyBeginAllowThreads();
46183 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46184 wxPyEndAllowThreads(__tstate);
46185 if (PyErr_Occurred()) SWIG_fail;
46186 }
46187 {
46188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46189 }
46190 {
46191 if (temp2)
46192 delete arg2;
46193 }
46194 return resultobj;
46195 fail:
46196 {
46197 if (temp2)
46198 delete arg2;
46199 }
46200 return NULL;
46201 }
46202
46203
46204 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46205 PyObject *resultobj = 0;
46206 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46207 wxString result;
46208 void *argp1 = 0 ;
46209 int res1 = 0 ;
46210 PyObject *swig_obj[1] ;
46211
46212 if (!args) SWIG_fail;
46213 swig_obj[0] = args;
46214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46215 if (!SWIG_IsOK(res1)) {
46216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46217 }
46218 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46219 {
46220 PyThreadState* __tstate = wxPyBeginAllowThreads();
46221 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46222 wxPyEndAllowThreads(__tstate);
46223 if (PyErr_Occurred()) SWIG_fail;
46224 }
46225 {
46226 #if wxUSE_UNICODE
46227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46228 #else
46229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46230 #endif
46231 }
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46241 int arg2 ;
46242 void *argp1 = 0 ;
46243 int res1 = 0 ;
46244 int val2 ;
46245 int ecode2 = 0 ;
46246 PyObject * obj0 = 0 ;
46247 PyObject * obj1 = 0 ;
46248 char * kwnames[] = {
46249 (char *) "self",(char *) "n", NULL
46250 };
46251
46252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46254 if (!SWIG_IsOK(res1)) {
46255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46256 }
46257 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46258 ecode2 = SWIG_AsVal_int(obj1, &val2);
46259 if (!SWIG_IsOK(ecode2)) {
46260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46261 }
46262 arg2 = static_cast< int >(val2);
46263 {
46264 PyThreadState* __tstate = wxPyBeginAllowThreads();
46265 (arg1)->Select(arg2);
46266 wxPyEndAllowThreads(__tstate);
46267 if (PyErr_Occurred()) SWIG_fail;
46268 }
46269 resultobj = SWIG_Py_Void();
46270 return resultobj;
46271 fail:
46272 return NULL;
46273 }
46274
46275
46276 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46277 PyObject *obj;
46278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46279 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46280 return SWIG_Py_Void();
46281 }
46282
46283 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46284 PyObject *obj;
46285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46286 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46287 return SWIG_Py_Void();
46288 }
46289
46290 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46291 PyObject *resultobj = 0;
46292 wxSizerItem *result = 0 ;
46293
46294 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46295 {
46296 PyThreadState* __tstate = wxPyBeginAllowThreads();
46297 result = (wxSizerItem *)new wxSizerItem();
46298 wxPyEndAllowThreads(__tstate);
46299 if (PyErr_Occurred()) SWIG_fail;
46300 }
46301 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46302 return resultobj;
46303 fail:
46304 return NULL;
46305 }
46306
46307
46308 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46309 PyObject *resultobj = 0;
46310 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 PyObject *swig_obj[1] ;
46314
46315 if (!args) SWIG_fail;
46316 swig_obj[0] = args;
46317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46320 }
46321 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 delete arg1;
46325
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = SWIG_Py_Void();
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46337 PyObject *resultobj = 0;
46338 wxWindow *arg1 = (wxWindow *) 0 ;
46339 int arg2 ;
46340 int arg3 ;
46341 int arg4 ;
46342 PyObject *arg5 = (PyObject *) NULL ;
46343 wxSizerItem *result = 0 ;
46344 void *argp1 = 0 ;
46345 int res1 = 0 ;
46346 int val2 ;
46347 int ecode2 = 0 ;
46348 int val3 ;
46349 int ecode3 = 0 ;
46350 int val4 ;
46351 int ecode4 = 0 ;
46352 PyObject * obj0 = 0 ;
46353 PyObject * obj1 = 0 ;
46354 PyObject * obj2 = 0 ;
46355 PyObject * obj3 = 0 ;
46356 PyObject * obj4 = 0 ;
46357 char * kwnames[] = {
46358 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46359 };
46360
46361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46363 if (!SWIG_IsOK(res1)) {
46364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46365 }
46366 arg1 = reinterpret_cast< wxWindow * >(argp1);
46367 ecode2 = SWIG_AsVal_int(obj1, &val2);
46368 if (!SWIG_IsOK(ecode2)) {
46369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46370 }
46371 arg2 = static_cast< int >(val2);
46372 ecode3 = SWIG_AsVal_int(obj2, &val3);
46373 if (!SWIG_IsOK(ecode3)) {
46374 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46375 }
46376 arg3 = static_cast< int >(val3);
46377 ecode4 = SWIG_AsVal_int(obj3, &val4);
46378 if (!SWIG_IsOK(ecode4)) {
46379 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46380 }
46381 arg4 = static_cast< int >(val4);
46382 if (obj4) {
46383 arg5 = obj4;
46384 }
46385 {
46386 PyThreadState* __tstate = wxPyBeginAllowThreads();
46387 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46399 PyObject *resultobj = 0;
46400 int arg1 ;
46401 int arg2 ;
46402 int arg3 ;
46403 int arg4 ;
46404 int arg5 ;
46405 PyObject *arg6 = (PyObject *) NULL ;
46406 wxSizerItem *result = 0 ;
46407 int val1 ;
46408 int ecode1 = 0 ;
46409 int val2 ;
46410 int ecode2 = 0 ;
46411 int val3 ;
46412 int ecode3 = 0 ;
46413 int val4 ;
46414 int ecode4 = 0 ;
46415 int val5 ;
46416 int ecode5 = 0 ;
46417 PyObject * obj0 = 0 ;
46418 PyObject * obj1 = 0 ;
46419 PyObject * obj2 = 0 ;
46420 PyObject * obj3 = 0 ;
46421 PyObject * obj4 = 0 ;
46422 PyObject * obj5 = 0 ;
46423 char * kwnames[] = {
46424 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46425 };
46426
46427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46428 ecode1 = SWIG_AsVal_int(obj0, &val1);
46429 if (!SWIG_IsOK(ecode1)) {
46430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46431 }
46432 arg1 = static_cast< int >(val1);
46433 ecode2 = SWIG_AsVal_int(obj1, &val2);
46434 if (!SWIG_IsOK(ecode2)) {
46435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46436 }
46437 arg2 = static_cast< int >(val2);
46438 ecode3 = SWIG_AsVal_int(obj2, &val3);
46439 if (!SWIG_IsOK(ecode3)) {
46440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46441 }
46442 arg3 = static_cast< int >(val3);
46443 ecode4 = SWIG_AsVal_int(obj3, &val4);
46444 if (!SWIG_IsOK(ecode4)) {
46445 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46446 }
46447 arg4 = static_cast< int >(val4);
46448 ecode5 = SWIG_AsVal_int(obj4, &val5);
46449 if (!SWIG_IsOK(ecode5)) {
46450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46451 }
46452 arg5 = static_cast< int >(val5);
46453 if (obj5) {
46454 arg6 = obj5;
46455 }
46456 {
46457 PyThreadState* __tstate = wxPyBeginAllowThreads();
46458 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46459 wxPyEndAllowThreads(__tstate);
46460 if (PyErr_Occurred()) SWIG_fail;
46461 }
46462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46463 return resultobj;
46464 fail:
46465 return NULL;
46466 }
46467
46468
46469 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46470 PyObject *resultobj = 0;
46471 wxSizer *arg1 = (wxSizer *) 0 ;
46472 int arg2 ;
46473 int arg3 ;
46474 int arg4 ;
46475 PyObject *arg5 = (PyObject *) NULL ;
46476 wxSizerItem *result = 0 ;
46477 int res1 = 0 ;
46478 int val2 ;
46479 int ecode2 = 0 ;
46480 int val3 ;
46481 int ecode3 = 0 ;
46482 int val4 ;
46483 int ecode4 = 0 ;
46484 PyObject * obj0 = 0 ;
46485 PyObject * obj1 = 0 ;
46486 PyObject * obj2 = 0 ;
46487 PyObject * obj3 = 0 ;
46488 PyObject * obj4 = 0 ;
46489 char * kwnames[] = {
46490 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46491 };
46492
46493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46494 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46495 if (!SWIG_IsOK(res1)) {
46496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46497 }
46498 ecode2 = SWIG_AsVal_int(obj1, &val2);
46499 if (!SWIG_IsOK(ecode2)) {
46500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46501 }
46502 arg2 = static_cast< int >(val2);
46503 ecode3 = SWIG_AsVal_int(obj2, &val3);
46504 if (!SWIG_IsOK(ecode3)) {
46505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46506 }
46507 arg3 = static_cast< int >(val3);
46508 ecode4 = SWIG_AsVal_int(obj3, &val4);
46509 if (!SWIG_IsOK(ecode4)) {
46510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46511 }
46512 arg4 = static_cast< int >(val4);
46513 if (obj4) {
46514 arg5 = obj4;
46515 }
46516 {
46517 PyThreadState* __tstate = wxPyBeginAllowThreads();
46518 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46519 wxPyEndAllowThreads(__tstate);
46520 if (PyErr_Occurred()) SWIG_fail;
46521 }
46522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46523 return resultobj;
46524 fail:
46525 return NULL;
46526 }
46527
46528
46529 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46530 PyObject *resultobj = 0;
46531 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46532 void *argp1 = 0 ;
46533 int res1 = 0 ;
46534 PyObject *swig_obj[1] ;
46535
46536 if (!args) SWIG_fail;
46537 swig_obj[0] = args;
46538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46539 if (!SWIG_IsOK(res1)) {
46540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46541 }
46542 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46543 {
46544 PyThreadState* __tstate = wxPyBeginAllowThreads();
46545 (arg1)->DeleteWindows();
46546 wxPyEndAllowThreads(__tstate);
46547 if (PyErr_Occurred()) SWIG_fail;
46548 }
46549 resultobj = SWIG_Py_Void();
46550 return resultobj;
46551 fail:
46552 return NULL;
46553 }
46554
46555
46556 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46557 PyObject *resultobj = 0;
46558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46559 void *argp1 = 0 ;
46560 int res1 = 0 ;
46561 PyObject *swig_obj[1] ;
46562
46563 if (!args) SWIG_fail;
46564 swig_obj[0] = args;
46565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46566 if (!SWIG_IsOK(res1)) {
46567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46568 }
46569 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46570 {
46571 PyThreadState* __tstate = wxPyBeginAllowThreads();
46572 (arg1)->DetachSizer();
46573 wxPyEndAllowThreads(__tstate);
46574 if (PyErr_Occurred()) SWIG_fail;
46575 }
46576 resultobj = SWIG_Py_Void();
46577 return resultobj;
46578 fail:
46579 return NULL;
46580 }
46581
46582
46583 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46584 PyObject *resultobj = 0;
46585 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46586 wxSize result;
46587 void *argp1 = 0 ;
46588 int res1 = 0 ;
46589 PyObject *swig_obj[1] ;
46590
46591 if (!args) SWIG_fail;
46592 swig_obj[0] = args;
46593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46594 if (!SWIG_IsOK(res1)) {
46595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46596 }
46597 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46598 {
46599 PyThreadState* __tstate = wxPyBeginAllowThreads();
46600 result = (arg1)->GetSize();
46601 wxPyEndAllowThreads(__tstate);
46602 if (PyErr_Occurred()) SWIG_fail;
46603 }
46604 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46605 return resultobj;
46606 fail:
46607 return NULL;
46608 }
46609
46610
46611 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46612 PyObject *resultobj = 0;
46613 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46614 wxSize result;
46615 void *argp1 = 0 ;
46616 int res1 = 0 ;
46617 PyObject *swig_obj[1] ;
46618
46619 if (!args) SWIG_fail;
46620 swig_obj[0] = args;
46621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46622 if (!SWIG_IsOK(res1)) {
46623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46624 }
46625 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46626 {
46627 PyThreadState* __tstate = wxPyBeginAllowThreads();
46628 result = (arg1)->CalcMin();
46629 wxPyEndAllowThreads(__tstate);
46630 if (PyErr_Occurred()) SWIG_fail;
46631 }
46632 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46633 return resultobj;
46634 fail:
46635 return NULL;
46636 }
46637
46638
46639 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46640 PyObject *resultobj = 0;
46641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46642 wxPoint *arg2 = 0 ;
46643 wxSize *arg3 = 0 ;
46644 void *argp1 = 0 ;
46645 int res1 = 0 ;
46646 wxPoint temp2 ;
46647 wxSize temp3 ;
46648 PyObject * obj0 = 0 ;
46649 PyObject * obj1 = 0 ;
46650 PyObject * obj2 = 0 ;
46651 char * kwnames[] = {
46652 (char *) "self",(char *) "pos",(char *) "size", NULL
46653 };
46654
46655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46657 if (!SWIG_IsOK(res1)) {
46658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46659 }
46660 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46661 {
46662 arg2 = &temp2;
46663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46664 }
46665 {
46666 arg3 = &temp3;
46667 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46668 }
46669 {
46670 PyThreadState* __tstate = wxPyBeginAllowThreads();
46671 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
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_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46683 PyObject *resultobj = 0;
46684 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46685 wxSize result;
46686 void *argp1 = 0 ;
46687 int res1 = 0 ;
46688 PyObject *swig_obj[1] ;
46689
46690 if (!args) SWIG_fail;
46691 swig_obj[0] = args;
46692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46693 if (!SWIG_IsOK(res1)) {
46694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46695 }
46696 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46697 {
46698 PyThreadState* __tstate = wxPyBeginAllowThreads();
46699 result = (arg1)->GetMinSize();
46700 wxPyEndAllowThreads(__tstate);
46701 if (PyErr_Occurred()) SWIG_fail;
46702 }
46703 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46704 return resultobj;
46705 fail:
46706 return NULL;
46707 }
46708
46709
46710 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46711 PyObject *resultobj = 0;
46712 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46713 wxSize result;
46714 void *argp1 = 0 ;
46715 int res1 = 0 ;
46716 PyObject *swig_obj[1] ;
46717
46718 if (!args) SWIG_fail;
46719 swig_obj[0] = args;
46720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46721 if (!SWIG_IsOK(res1)) {
46722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46723 }
46724 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46725 {
46726 PyThreadState* __tstate = wxPyBeginAllowThreads();
46727 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46728 wxPyEndAllowThreads(__tstate);
46729 if (PyErr_Occurred()) SWIG_fail;
46730 }
46731 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46732 return resultobj;
46733 fail:
46734 return NULL;
46735 }
46736
46737
46738 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46739 PyObject *resultobj = 0;
46740 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46741 int arg2 ;
46742 int arg3 ;
46743 void *argp1 = 0 ;
46744 int res1 = 0 ;
46745 int val2 ;
46746 int ecode2 = 0 ;
46747 int val3 ;
46748 int ecode3 = 0 ;
46749 PyObject * obj0 = 0 ;
46750 PyObject * obj1 = 0 ;
46751 PyObject * obj2 = 0 ;
46752 char * kwnames[] = {
46753 (char *) "self",(char *) "x",(char *) "y", NULL
46754 };
46755
46756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46758 if (!SWIG_IsOK(res1)) {
46759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46760 }
46761 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46762 ecode2 = SWIG_AsVal_int(obj1, &val2);
46763 if (!SWIG_IsOK(ecode2)) {
46764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46765 }
46766 arg2 = static_cast< int >(val2);
46767 ecode3 = SWIG_AsVal_int(obj2, &val3);
46768 if (!SWIG_IsOK(ecode3)) {
46769 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46770 }
46771 arg3 = static_cast< int >(val3);
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 (arg1)->SetInitSize(arg2,arg3);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_Py_Void();
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46788 int arg2 ;
46789 int arg3 ;
46790 void *argp1 = 0 ;
46791 int res1 = 0 ;
46792 int val2 ;
46793 int ecode2 = 0 ;
46794 int val3 ;
46795 int ecode3 = 0 ;
46796 PyObject * obj0 = 0 ;
46797 PyObject * obj1 = 0 ;
46798 PyObject * obj2 = 0 ;
46799 char * kwnames[] = {
46800 (char *) "self",(char *) "width",(char *) "height", NULL
46801 };
46802
46803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46805 if (!SWIG_IsOK(res1)) {
46806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46807 }
46808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46809 ecode2 = SWIG_AsVal_int(obj1, &val2);
46810 if (!SWIG_IsOK(ecode2)) {
46811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46812 }
46813 arg2 = static_cast< int >(val2);
46814 ecode3 = SWIG_AsVal_int(obj2, &val3);
46815 if (!SWIG_IsOK(ecode3)) {
46816 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46817 }
46818 arg3 = static_cast< int >(val3);
46819 {
46820 PyThreadState* __tstate = wxPyBeginAllowThreads();
46821 (arg1)->SetRatio(arg2,arg3);
46822 wxPyEndAllowThreads(__tstate);
46823 if (PyErr_Occurred()) SWIG_fail;
46824 }
46825 resultobj = SWIG_Py_Void();
46826 return resultobj;
46827 fail:
46828 return NULL;
46829 }
46830
46831
46832 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46833 PyObject *resultobj = 0;
46834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46835 wxSize *arg2 = 0 ;
46836 void *argp1 = 0 ;
46837 int res1 = 0 ;
46838 wxSize temp2 ;
46839 PyObject * obj0 = 0 ;
46840 PyObject * obj1 = 0 ;
46841 char * kwnames[] = {
46842 (char *) "self",(char *) "size", NULL
46843 };
46844
46845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46847 if (!SWIG_IsOK(res1)) {
46848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46849 }
46850 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46851 {
46852 arg2 = &temp2;
46853 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46854 }
46855 {
46856 PyThreadState* __tstate = wxPyBeginAllowThreads();
46857 (arg1)->SetRatio((wxSize const &)*arg2);
46858 wxPyEndAllowThreads(__tstate);
46859 if (PyErr_Occurred()) SWIG_fail;
46860 }
46861 resultobj = SWIG_Py_Void();
46862 return resultobj;
46863 fail:
46864 return NULL;
46865 }
46866
46867
46868 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46869 PyObject *resultobj = 0;
46870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46871 float arg2 ;
46872 void *argp1 = 0 ;
46873 int res1 = 0 ;
46874 float val2 ;
46875 int ecode2 = 0 ;
46876 PyObject * obj0 = 0 ;
46877 PyObject * obj1 = 0 ;
46878 char * kwnames[] = {
46879 (char *) "self",(char *) "ratio", NULL
46880 };
46881
46882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46884 if (!SWIG_IsOK(res1)) {
46885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46886 }
46887 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46888 ecode2 = SWIG_AsVal_float(obj1, &val2);
46889 if (!SWIG_IsOK(ecode2)) {
46890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46891 }
46892 arg2 = static_cast< float >(val2);
46893 {
46894 PyThreadState* __tstate = wxPyBeginAllowThreads();
46895 (arg1)->SetRatio(arg2);
46896 wxPyEndAllowThreads(__tstate);
46897 if (PyErr_Occurred()) SWIG_fail;
46898 }
46899 resultobj = SWIG_Py_Void();
46900 return resultobj;
46901 fail:
46902 return NULL;
46903 }
46904
46905
46906 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46907 PyObject *resultobj = 0;
46908 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46909 float result;
46910 void *argp1 = 0 ;
46911 int res1 = 0 ;
46912 PyObject *swig_obj[1] ;
46913
46914 if (!args) SWIG_fail;
46915 swig_obj[0] = args;
46916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46917 if (!SWIG_IsOK(res1)) {
46918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46919 }
46920 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46921 {
46922 PyThreadState* __tstate = wxPyBeginAllowThreads();
46923 result = (float)(arg1)->GetRatio();
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 resultobj = SWIG_From_float(static_cast< float >(result));
46928 return resultobj;
46929 fail:
46930 return NULL;
46931 }
46932
46933
46934 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46935 PyObject *resultobj = 0;
46936 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46937 wxRect result;
46938 void *argp1 = 0 ;
46939 int res1 = 0 ;
46940 PyObject *swig_obj[1] ;
46941
46942 if (!args) SWIG_fail;
46943 swig_obj[0] = args;
46944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46945 if (!SWIG_IsOK(res1)) {
46946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46947 }
46948 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46949 {
46950 PyThreadState* __tstate = wxPyBeginAllowThreads();
46951 result = (arg1)->GetRect();
46952 wxPyEndAllowThreads(__tstate);
46953 if (PyErr_Occurred()) SWIG_fail;
46954 }
46955 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46956 return resultobj;
46957 fail:
46958 return NULL;
46959 }
46960
46961
46962 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46963 PyObject *resultobj = 0;
46964 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46965 bool result;
46966 void *argp1 = 0 ;
46967 int res1 = 0 ;
46968 PyObject *swig_obj[1] ;
46969
46970 if (!args) SWIG_fail;
46971 swig_obj[0] = args;
46972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46973 if (!SWIG_IsOK(res1)) {
46974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46975 }
46976 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46977 {
46978 PyThreadState* __tstate = wxPyBeginAllowThreads();
46979 result = (bool)(arg1)->IsWindow();
46980 wxPyEndAllowThreads(__tstate);
46981 if (PyErr_Occurred()) SWIG_fail;
46982 }
46983 {
46984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46985 }
46986 return resultobj;
46987 fail:
46988 return NULL;
46989 }
46990
46991
46992 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46993 PyObject *resultobj = 0;
46994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46995 bool result;
46996 void *argp1 = 0 ;
46997 int res1 = 0 ;
46998 PyObject *swig_obj[1] ;
46999
47000 if (!args) SWIG_fail;
47001 swig_obj[0] = args;
47002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47003 if (!SWIG_IsOK(res1)) {
47004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47005 }
47006 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47007 {
47008 PyThreadState* __tstate = wxPyBeginAllowThreads();
47009 result = (bool)(arg1)->IsSizer();
47010 wxPyEndAllowThreads(__tstate);
47011 if (PyErr_Occurred()) SWIG_fail;
47012 }
47013 {
47014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47015 }
47016 return resultobj;
47017 fail:
47018 return NULL;
47019 }
47020
47021
47022 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47023 PyObject *resultobj = 0;
47024 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47025 bool result;
47026 void *argp1 = 0 ;
47027 int res1 = 0 ;
47028 PyObject *swig_obj[1] ;
47029
47030 if (!args) SWIG_fail;
47031 swig_obj[0] = args;
47032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47033 if (!SWIG_IsOK(res1)) {
47034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47035 }
47036 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47037 {
47038 PyThreadState* __tstate = wxPyBeginAllowThreads();
47039 result = (bool)(arg1)->IsSpacer();
47040 wxPyEndAllowThreads(__tstate);
47041 if (PyErr_Occurred()) SWIG_fail;
47042 }
47043 {
47044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47045 }
47046 return resultobj;
47047 fail:
47048 return NULL;
47049 }
47050
47051
47052 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47053 PyObject *resultobj = 0;
47054 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47055 int arg2 ;
47056 void *argp1 = 0 ;
47057 int res1 = 0 ;
47058 int val2 ;
47059 int ecode2 = 0 ;
47060 PyObject * obj0 = 0 ;
47061 PyObject * obj1 = 0 ;
47062 char * kwnames[] = {
47063 (char *) "self",(char *) "proportion", NULL
47064 };
47065
47066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47068 if (!SWIG_IsOK(res1)) {
47069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47070 }
47071 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47072 ecode2 = SWIG_AsVal_int(obj1, &val2);
47073 if (!SWIG_IsOK(ecode2)) {
47074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47075 }
47076 arg2 = static_cast< int >(val2);
47077 {
47078 PyThreadState* __tstate = wxPyBeginAllowThreads();
47079 (arg1)->SetProportion(arg2);
47080 wxPyEndAllowThreads(__tstate);
47081 if (PyErr_Occurred()) SWIG_fail;
47082 }
47083 resultobj = SWIG_Py_Void();
47084 return resultobj;
47085 fail:
47086 return NULL;
47087 }
47088
47089
47090 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47091 PyObject *resultobj = 0;
47092 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47093 int result;
47094 void *argp1 = 0 ;
47095 int res1 = 0 ;
47096 PyObject *swig_obj[1] ;
47097
47098 if (!args) SWIG_fail;
47099 swig_obj[0] = args;
47100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47101 if (!SWIG_IsOK(res1)) {
47102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47103 }
47104 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47105 {
47106 PyThreadState* __tstate = wxPyBeginAllowThreads();
47107 result = (int)(arg1)->GetProportion();
47108 wxPyEndAllowThreads(__tstate);
47109 if (PyErr_Occurred()) SWIG_fail;
47110 }
47111 resultobj = SWIG_From_int(static_cast< int >(result));
47112 return resultobj;
47113 fail:
47114 return NULL;
47115 }
47116
47117
47118 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47119 PyObject *resultobj = 0;
47120 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47121 int arg2 ;
47122 void *argp1 = 0 ;
47123 int res1 = 0 ;
47124 int val2 ;
47125 int ecode2 = 0 ;
47126 PyObject * obj0 = 0 ;
47127 PyObject * obj1 = 0 ;
47128 char * kwnames[] = {
47129 (char *) "self",(char *) "flag", NULL
47130 };
47131
47132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47134 if (!SWIG_IsOK(res1)) {
47135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47136 }
47137 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47138 ecode2 = SWIG_AsVal_int(obj1, &val2);
47139 if (!SWIG_IsOK(ecode2)) {
47140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47141 }
47142 arg2 = static_cast< int >(val2);
47143 {
47144 PyThreadState* __tstate = wxPyBeginAllowThreads();
47145 (arg1)->SetFlag(arg2);
47146 wxPyEndAllowThreads(__tstate);
47147 if (PyErr_Occurred()) SWIG_fail;
47148 }
47149 resultobj = SWIG_Py_Void();
47150 return resultobj;
47151 fail:
47152 return NULL;
47153 }
47154
47155
47156 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47157 PyObject *resultobj = 0;
47158 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47159 int result;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 PyObject *swig_obj[1] ;
47163
47164 if (!args) SWIG_fail;
47165 swig_obj[0] = args;
47166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47167 if (!SWIG_IsOK(res1)) {
47168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47169 }
47170 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47171 {
47172 PyThreadState* __tstate = wxPyBeginAllowThreads();
47173 result = (int)(arg1)->GetFlag();
47174 wxPyEndAllowThreads(__tstate);
47175 if (PyErr_Occurred()) SWIG_fail;
47176 }
47177 resultobj = SWIG_From_int(static_cast< int >(result));
47178 return resultobj;
47179 fail:
47180 return NULL;
47181 }
47182
47183
47184 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47185 PyObject *resultobj = 0;
47186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47187 int arg2 ;
47188 void *argp1 = 0 ;
47189 int res1 = 0 ;
47190 int val2 ;
47191 int ecode2 = 0 ;
47192 PyObject * obj0 = 0 ;
47193 PyObject * obj1 = 0 ;
47194 char * kwnames[] = {
47195 (char *) "self",(char *) "border", NULL
47196 };
47197
47198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47200 if (!SWIG_IsOK(res1)) {
47201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47202 }
47203 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47204 ecode2 = SWIG_AsVal_int(obj1, &val2);
47205 if (!SWIG_IsOK(ecode2)) {
47206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47207 }
47208 arg2 = static_cast< int >(val2);
47209 {
47210 PyThreadState* __tstate = wxPyBeginAllowThreads();
47211 (arg1)->SetBorder(arg2);
47212 wxPyEndAllowThreads(__tstate);
47213 if (PyErr_Occurred()) SWIG_fail;
47214 }
47215 resultobj = SWIG_Py_Void();
47216 return resultobj;
47217 fail:
47218 return NULL;
47219 }
47220
47221
47222 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47223 PyObject *resultobj = 0;
47224 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47225 int result;
47226 void *argp1 = 0 ;
47227 int res1 = 0 ;
47228 PyObject *swig_obj[1] ;
47229
47230 if (!args) SWIG_fail;
47231 swig_obj[0] = args;
47232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47233 if (!SWIG_IsOK(res1)) {
47234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47235 }
47236 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47237 {
47238 PyThreadState* __tstate = wxPyBeginAllowThreads();
47239 result = (int)(arg1)->GetBorder();
47240 wxPyEndAllowThreads(__tstate);
47241 if (PyErr_Occurred()) SWIG_fail;
47242 }
47243 resultobj = SWIG_From_int(static_cast< int >(result));
47244 return resultobj;
47245 fail:
47246 return NULL;
47247 }
47248
47249
47250 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47251 PyObject *resultobj = 0;
47252 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47253 wxWindow *result = 0 ;
47254 void *argp1 = 0 ;
47255 int res1 = 0 ;
47256 PyObject *swig_obj[1] ;
47257
47258 if (!args) SWIG_fail;
47259 swig_obj[0] = args;
47260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47261 if (!SWIG_IsOK(res1)) {
47262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47263 }
47264 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47265 {
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 result = (wxWindow *)(arg1)->GetWindow();
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 {
47272 resultobj = wxPyMake_wxObject(result, 0);
47273 }
47274 return resultobj;
47275 fail:
47276 return NULL;
47277 }
47278
47279
47280 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47281 PyObject *resultobj = 0;
47282 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47283 wxWindow *arg2 = (wxWindow *) 0 ;
47284 void *argp1 = 0 ;
47285 int res1 = 0 ;
47286 void *argp2 = 0 ;
47287 int res2 = 0 ;
47288 PyObject * obj0 = 0 ;
47289 PyObject * obj1 = 0 ;
47290 char * kwnames[] = {
47291 (char *) "self",(char *) "window", NULL
47292 };
47293
47294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47298 }
47299 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47301 if (!SWIG_IsOK(res2)) {
47302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47303 }
47304 arg2 = reinterpret_cast< wxWindow * >(argp2);
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 (arg1)->SetWindow(arg2);
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_Py_Void();
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47319 PyObject *resultobj = 0;
47320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47321 wxSizer *result = 0 ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 PyObject *swig_obj[1] ;
47325
47326 if (!args) SWIG_fail;
47327 swig_obj[0] = args;
47328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47329 if (!SWIG_IsOK(res1)) {
47330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47331 }
47332 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47333 {
47334 PyThreadState* __tstate = wxPyBeginAllowThreads();
47335 result = (wxSizer *)(arg1)->GetSizer();
47336 wxPyEndAllowThreads(__tstate);
47337 if (PyErr_Occurred()) SWIG_fail;
47338 }
47339 {
47340 resultobj = wxPyMake_wxObject(result, (bool)0);
47341 }
47342 return resultobj;
47343 fail:
47344 return NULL;
47345 }
47346
47347
47348 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47349 PyObject *resultobj = 0;
47350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47351 wxSizer *arg2 = (wxSizer *) 0 ;
47352 void *argp1 = 0 ;
47353 int res1 = 0 ;
47354 int res2 = 0 ;
47355 PyObject * obj0 = 0 ;
47356 PyObject * obj1 = 0 ;
47357 char * kwnames[] = {
47358 (char *) "self",(char *) "sizer", NULL
47359 };
47360
47361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47363 if (!SWIG_IsOK(res1)) {
47364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47365 }
47366 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47367 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47368 if (!SWIG_IsOK(res2)) {
47369 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47370 }
47371 {
47372 PyThreadState* __tstate = wxPyBeginAllowThreads();
47373 (arg1)->SetSizer(arg2);
47374 wxPyEndAllowThreads(__tstate);
47375 if (PyErr_Occurred()) SWIG_fail;
47376 }
47377 resultobj = SWIG_Py_Void();
47378 return resultobj;
47379 fail:
47380 return NULL;
47381 }
47382
47383
47384 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47385 PyObject *resultobj = 0;
47386 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47387 wxSize result;
47388 void *argp1 = 0 ;
47389 int res1 = 0 ;
47390 PyObject *swig_obj[1] ;
47391
47392 if (!args) SWIG_fail;
47393 swig_obj[0] = args;
47394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47395 if (!SWIG_IsOK(res1)) {
47396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47397 }
47398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47399 {
47400 PyThreadState* __tstate = wxPyBeginAllowThreads();
47401 result = (arg1)->GetSpacer();
47402 wxPyEndAllowThreads(__tstate);
47403 if (PyErr_Occurred()) SWIG_fail;
47404 }
47405 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47406 return resultobj;
47407 fail:
47408 return NULL;
47409 }
47410
47411
47412 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47413 PyObject *resultobj = 0;
47414 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47415 wxSize *arg2 = 0 ;
47416 void *argp1 = 0 ;
47417 int res1 = 0 ;
47418 wxSize temp2 ;
47419 PyObject * obj0 = 0 ;
47420 PyObject * obj1 = 0 ;
47421 char * kwnames[] = {
47422 (char *) "self",(char *) "size", NULL
47423 };
47424
47425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47427 if (!SWIG_IsOK(res1)) {
47428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47429 }
47430 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47431 {
47432 arg2 = &temp2;
47433 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47434 }
47435 {
47436 PyThreadState* __tstate = wxPyBeginAllowThreads();
47437 (arg1)->SetSpacer((wxSize const &)*arg2);
47438 wxPyEndAllowThreads(__tstate);
47439 if (PyErr_Occurred()) SWIG_fail;
47440 }
47441 resultobj = SWIG_Py_Void();
47442 return resultobj;
47443 fail:
47444 return NULL;
47445 }
47446
47447
47448 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47449 PyObject *resultobj = 0;
47450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47451 bool arg2 ;
47452 void *argp1 = 0 ;
47453 int res1 = 0 ;
47454 bool val2 ;
47455 int ecode2 = 0 ;
47456 PyObject * obj0 = 0 ;
47457 PyObject * obj1 = 0 ;
47458 char * kwnames[] = {
47459 (char *) "self",(char *) "show", NULL
47460 };
47461
47462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47464 if (!SWIG_IsOK(res1)) {
47465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47466 }
47467 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47468 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47469 if (!SWIG_IsOK(ecode2)) {
47470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47471 }
47472 arg2 = static_cast< bool >(val2);
47473 {
47474 PyThreadState* __tstate = wxPyBeginAllowThreads();
47475 (arg1)->Show(arg2);
47476 wxPyEndAllowThreads(__tstate);
47477 if (PyErr_Occurred()) SWIG_fail;
47478 }
47479 resultobj = SWIG_Py_Void();
47480 return resultobj;
47481 fail:
47482 return NULL;
47483 }
47484
47485
47486 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47487 PyObject *resultobj = 0;
47488 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47489 bool result;
47490 void *argp1 = 0 ;
47491 int res1 = 0 ;
47492 PyObject *swig_obj[1] ;
47493
47494 if (!args) SWIG_fail;
47495 swig_obj[0] = args;
47496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47497 if (!SWIG_IsOK(res1)) {
47498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47499 }
47500 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47501 {
47502 PyThreadState* __tstate = wxPyBeginAllowThreads();
47503 result = (bool)(arg1)->IsShown();
47504 wxPyEndAllowThreads(__tstate);
47505 if (PyErr_Occurred()) SWIG_fail;
47506 }
47507 {
47508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47509 }
47510 return resultobj;
47511 fail:
47512 return NULL;
47513 }
47514
47515
47516 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47517 PyObject *resultobj = 0;
47518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47519 wxPoint result;
47520 void *argp1 = 0 ;
47521 int res1 = 0 ;
47522 PyObject *swig_obj[1] ;
47523
47524 if (!args) SWIG_fail;
47525 swig_obj[0] = args;
47526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47527 if (!SWIG_IsOK(res1)) {
47528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47529 }
47530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47531 {
47532 PyThreadState* __tstate = wxPyBeginAllowThreads();
47533 result = (arg1)->GetPosition();
47534 wxPyEndAllowThreads(__tstate);
47535 if (PyErr_Occurred()) SWIG_fail;
47536 }
47537 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47538 return resultobj;
47539 fail:
47540 return NULL;
47541 }
47542
47543
47544 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47545 PyObject *resultobj = 0;
47546 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47547 PyObject *result = 0 ;
47548 void *argp1 = 0 ;
47549 int res1 = 0 ;
47550 PyObject *swig_obj[1] ;
47551
47552 if (!args) SWIG_fail;
47553 swig_obj[0] = args;
47554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47555 if (!SWIG_IsOK(res1)) {
47556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47557 }
47558 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47559 {
47560 PyThreadState* __tstate = wxPyBeginAllowThreads();
47561 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47562 wxPyEndAllowThreads(__tstate);
47563 if (PyErr_Occurred()) SWIG_fail;
47564 }
47565 resultobj = result;
47566 return resultobj;
47567 fail:
47568 return NULL;
47569 }
47570
47571
47572 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47573 PyObject *resultobj = 0;
47574 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47575 PyObject *arg2 = (PyObject *) 0 ;
47576 void *argp1 = 0 ;
47577 int res1 = 0 ;
47578 PyObject * obj0 = 0 ;
47579 PyObject * obj1 = 0 ;
47580 char * kwnames[] = {
47581 (char *) "self",(char *) "userData", NULL
47582 };
47583
47584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47586 if (!SWIG_IsOK(res1)) {
47587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47588 }
47589 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47590 arg2 = obj1;
47591 {
47592 PyThreadState* __tstate = wxPyBeginAllowThreads();
47593 wxSizerItem_SetUserData(arg1,arg2);
47594 wxPyEndAllowThreads(__tstate);
47595 if (PyErr_Occurred()) SWIG_fail;
47596 }
47597 resultobj = SWIG_Py_Void();
47598 return resultobj;
47599 fail:
47600 return NULL;
47601 }
47602
47603
47604 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47605 PyObject *obj;
47606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47607 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47608 return SWIG_Py_Void();
47609 }
47610
47611 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47612 return SWIG_Python_InitShadowInstance(args);
47613 }
47614
47615 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47616 PyObject *resultobj = 0;
47617 wxSizer *arg1 = (wxSizer *) 0 ;
47618 void *argp1 = 0 ;
47619 int res1 = 0 ;
47620 PyObject *swig_obj[1] ;
47621
47622 if (!args) SWIG_fail;
47623 swig_obj[0] = args;
47624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47625 if (!SWIG_IsOK(res1)) {
47626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47627 }
47628 arg1 = reinterpret_cast< wxSizer * >(argp1);
47629 {
47630 PyThreadState* __tstate = wxPyBeginAllowThreads();
47631 delete arg1;
47632
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = SWIG_Py_Void();
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47644 PyObject *resultobj = 0;
47645 wxSizer *arg1 = (wxSizer *) 0 ;
47646 PyObject *arg2 = (PyObject *) 0 ;
47647 void *argp1 = 0 ;
47648 int res1 = 0 ;
47649 PyObject * obj0 = 0 ;
47650 PyObject * obj1 = 0 ;
47651 char * kwnames[] = {
47652 (char *) "self",(char *) "_self", NULL
47653 };
47654
47655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47657 if (!SWIG_IsOK(res1)) {
47658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47659 }
47660 arg1 = reinterpret_cast< wxSizer * >(argp1);
47661 arg2 = obj1;
47662 {
47663 PyThreadState* __tstate = wxPyBeginAllowThreads();
47664 wxSizer__setOORInfo(arg1,arg2);
47665 wxPyEndAllowThreads(__tstate);
47666 if (PyErr_Occurred()) SWIG_fail;
47667 }
47668 resultobj = SWIG_Py_Void();
47669 return resultobj;
47670 fail:
47671 return NULL;
47672 }
47673
47674
47675 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47676 PyObject *resultobj = 0;
47677 wxSizer *arg1 = (wxSizer *) 0 ;
47678 PyObject *arg2 = (PyObject *) 0 ;
47679 int arg3 = (int) 0 ;
47680 int arg4 = (int) 0 ;
47681 int arg5 = (int) 0 ;
47682 PyObject *arg6 = (PyObject *) NULL ;
47683 wxSizerItem *result = 0 ;
47684 void *argp1 = 0 ;
47685 int res1 = 0 ;
47686 int val3 ;
47687 int ecode3 = 0 ;
47688 int val4 ;
47689 int ecode4 = 0 ;
47690 int val5 ;
47691 int ecode5 = 0 ;
47692 PyObject * obj0 = 0 ;
47693 PyObject * obj1 = 0 ;
47694 PyObject * obj2 = 0 ;
47695 PyObject * obj3 = 0 ;
47696 PyObject * obj4 = 0 ;
47697 PyObject * obj5 = 0 ;
47698 char * kwnames[] = {
47699 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47700 };
47701
47702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47704 if (!SWIG_IsOK(res1)) {
47705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47706 }
47707 arg1 = reinterpret_cast< wxSizer * >(argp1);
47708 arg2 = obj1;
47709 if (obj2) {
47710 ecode3 = SWIG_AsVal_int(obj2, &val3);
47711 if (!SWIG_IsOK(ecode3)) {
47712 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47713 }
47714 arg3 = static_cast< int >(val3);
47715 }
47716 if (obj3) {
47717 ecode4 = SWIG_AsVal_int(obj3, &val4);
47718 if (!SWIG_IsOK(ecode4)) {
47719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47720 }
47721 arg4 = static_cast< int >(val4);
47722 }
47723 if (obj4) {
47724 ecode5 = SWIG_AsVal_int(obj4, &val5);
47725 if (!SWIG_IsOK(ecode5)) {
47726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47727 }
47728 arg5 = static_cast< int >(val5);
47729 }
47730 if (obj5) {
47731 arg6 = obj5;
47732 }
47733 {
47734 PyThreadState* __tstate = wxPyBeginAllowThreads();
47735 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47736 wxPyEndAllowThreads(__tstate);
47737 if (PyErr_Occurred()) SWIG_fail;
47738 }
47739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47740 return resultobj;
47741 fail:
47742 return NULL;
47743 }
47744
47745
47746 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47747 PyObject *resultobj = 0;
47748 wxSizer *arg1 = (wxSizer *) 0 ;
47749 int arg2 ;
47750 PyObject *arg3 = (PyObject *) 0 ;
47751 int arg4 = (int) 0 ;
47752 int arg5 = (int) 0 ;
47753 int arg6 = (int) 0 ;
47754 PyObject *arg7 = (PyObject *) NULL ;
47755 wxSizerItem *result = 0 ;
47756 void *argp1 = 0 ;
47757 int res1 = 0 ;
47758 int val2 ;
47759 int ecode2 = 0 ;
47760 int val4 ;
47761 int ecode4 = 0 ;
47762 int val5 ;
47763 int ecode5 = 0 ;
47764 int val6 ;
47765 int ecode6 = 0 ;
47766 PyObject * obj0 = 0 ;
47767 PyObject * obj1 = 0 ;
47768 PyObject * obj2 = 0 ;
47769 PyObject * obj3 = 0 ;
47770 PyObject * obj4 = 0 ;
47771 PyObject * obj5 = 0 ;
47772 PyObject * obj6 = 0 ;
47773 char * kwnames[] = {
47774 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47775 };
47776
47777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47779 if (!SWIG_IsOK(res1)) {
47780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47781 }
47782 arg1 = reinterpret_cast< wxSizer * >(argp1);
47783 ecode2 = SWIG_AsVal_int(obj1, &val2);
47784 if (!SWIG_IsOK(ecode2)) {
47785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47786 }
47787 arg2 = static_cast< int >(val2);
47788 arg3 = obj2;
47789 if (obj3) {
47790 ecode4 = SWIG_AsVal_int(obj3, &val4);
47791 if (!SWIG_IsOK(ecode4)) {
47792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47793 }
47794 arg4 = static_cast< int >(val4);
47795 }
47796 if (obj4) {
47797 ecode5 = SWIG_AsVal_int(obj4, &val5);
47798 if (!SWIG_IsOK(ecode5)) {
47799 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47800 }
47801 arg5 = static_cast< int >(val5);
47802 }
47803 if (obj5) {
47804 ecode6 = SWIG_AsVal_int(obj5, &val6);
47805 if (!SWIG_IsOK(ecode6)) {
47806 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47807 }
47808 arg6 = static_cast< int >(val6);
47809 }
47810 if (obj6) {
47811 arg7 = obj6;
47812 }
47813 {
47814 PyThreadState* __tstate = wxPyBeginAllowThreads();
47815 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47816 wxPyEndAllowThreads(__tstate);
47817 if (PyErr_Occurred()) SWIG_fail;
47818 }
47819 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47820 return resultobj;
47821 fail:
47822 return NULL;
47823 }
47824
47825
47826 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47827 PyObject *resultobj = 0;
47828 wxSizer *arg1 = (wxSizer *) 0 ;
47829 PyObject *arg2 = (PyObject *) 0 ;
47830 int arg3 = (int) 0 ;
47831 int arg4 = (int) 0 ;
47832 int arg5 = (int) 0 ;
47833 PyObject *arg6 = (PyObject *) NULL ;
47834 wxSizerItem *result = 0 ;
47835 void *argp1 = 0 ;
47836 int res1 = 0 ;
47837 int val3 ;
47838 int ecode3 = 0 ;
47839 int val4 ;
47840 int ecode4 = 0 ;
47841 int val5 ;
47842 int ecode5 = 0 ;
47843 PyObject * obj0 = 0 ;
47844 PyObject * obj1 = 0 ;
47845 PyObject * obj2 = 0 ;
47846 PyObject * obj3 = 0 ;
47847 PyObject * obj4 = 0 ;
47848 PyObject * obj5 = 0 ;
47849 char * kwnames[] = {
47850 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47851 };
47852
47853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47855 if (!SWIG_IsOK(res1)) {
47856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47857 }
47858 arg1 = reinterpret_cast< wxSizer * >(argp1);
47859 arg2 = obj1;
47860 if (obj2) {
47861 ecode3 = SWIG_AsVal_int(obj2, &val3);
47862 if (!SWIG_IsOK(ecode3)) {
47863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47864 }
47865 arg3 = static_cast< int >(val3);
47866 }
47867 if (obj3) {
47868 ecode4 = SWIG_AsVal_int(obj3, &val4);
47869 if (!SWIG_IsOK(ecode4)) {
47870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47871 }
47872 arg4 = static_cast< int >(val4);
47873 }
47874 if (obj4) {
47875 ecode5 = SWIG_AsVal_int(obj4, &val5);
47876 if (!SWIG_IsOK(ecode5)) {
47877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47878 }
47879 arg5 = static_cast< int >(val5);
47880 }
47881 if (obj5) {
47882 arg6 = obj5;
47883 }
47884 {
47885 PyThreadState* __tstate = wxPyBeginAllowThreads();
47886 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47887 wxPyEndAllowThreads(__tstate);
47888 if (PyErr_Occurred()) SWIG_fail;
47889 }
47890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47891 return resultobj;
47892 fail:
47893 return NULL;
47894 }
47895
47896
47897 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47898 PyObject *resultobj = 0;
47899 wxSizer *arg1 = (wxSizer *) 0 ;
47900 PyObject *arg2 = (PyObject *) 0 ;
47901 bool result;
47902 void *argp1 = 0 ;
47903 int res1 = 0 ;
47904 PyObject * obj0 = 0 ;
47905 PyObject * obj1 = 0 ;
47906 char * kwnames[] = {
47907 (char *) "self",(char *) "item", NULL
47908 };
47909
47910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47912 if (!SWIG_IsOK(res1)) {
47913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47914 }
47915 arg1 = reinterpret_cast< wxSizer * >(argp1);
47916 arg2 = obj1;
47917 {
47918 PyThreadState* __tstate = wxPyBeginAllowThreads();
47919 result = (bool)wxSizer_Remove(arg1,arg2);
47920 wxPyEndAllowThreads(__tstate);
47921 if (PyErr_Occurred()) SWIG_fail;
47922 }
47923 {
47924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47925 }
47926 return resultobj;
47927 fail:
47928 return NULL;
47929 }
47930
47931
47932 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47933 PyObject *resultobj = 0;
47934 wxSizer *arg1 = (wxSizer *) 0 ;
47935 PyObject *arg2 = (PyObject *) 0 ;
47936 bool result;
47937 void *argp1 = 0 ;
47938 int res1 = 0 ;
47939 PyObject * obj0 = 0 ;
47940 PyObject * obj1 = 0 ;
47941 char * kwnames[] = {
47942 (char *) "self",(char *) "item", NULL
47943 };
47944
47945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47947 if (!SWIG_IsOK(res1)) {
47948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47949 }
47950 arg1 = reinterpret_cast< wxSizer * >(argp1);
47951 arg2 = obj1;
47952 {
47953 PyThreadState* __tstate = wxPyBeginAllowThreads();
47954 result = (bool)wxSizer_Detach(arg1,arg2);
47955 wxPyEndAllowThreads(__tstate);
47956 if (PyErr_Occurred()) SWIG_fail;
47957 }
47958 {
47959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47960 }
47961 return resultobj;
47962 fail:
47963 return NULL;
47964 }
47965
47966
47967 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47968 PyObject *resultobj = 0;
47969 wxSizer *arg1 = (wxSizer *) 0 ;
47970 PyObject *arg2 = (PyObject *) 0 ;
47971 wxSizerItem *result = 0 ;
47972 void *argp1 = 0 ;
47973 int res1 = 0 ;
47974 PyObject * obj0 = 0 ;
47975 PyObject * obj1 = 0 ;
47976 char * kwnames[] = {
47977 (char *) "self",(char *) "item", NULL
47978 };
47979
47980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47982 if (!SWIG_IsOK(res1)) {
47983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47984 }
47985 arg1 = reinterpret_cast< wxSizer * >(argp1);
47986 arg2 = obj1;
47987 {
47988 PyThreadState* __tstate = wxPyBeginAllowThreads();
47989 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47990 wxPyEndAllowThreads(__tstate);
47991 if (PyErr_Occurred()) SWIG_fail;
47992 }
47993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47994 return resultobj;
47995 fail:
47996 return NULL;
47997 }
47998
47999
48000 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48001 PyObject *resultobj = 0;
48002 wxSizer *arg1 = (wxSizer *) 0 ;
48003 PyObject *arg2 = (PyObject *) 0 ;
48004 wxSize *arg3 = 0 ;
48005 void *argp1 = 0 ;
48006 int res1 = 0 ;
48007 wxSize temp3 ;
48008 PyObject * obj0 = 0 ;
48009 PyObject * obj1 = 0 ;
48010 PyObject * obj2 = 0 ;
48011 char * kwnames[] = {
48012 (char *) "self",(char *) "item",(char *) "size", NULL
48013 };
48014
48015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48017 if (!SWIG_IsOK(res1)) {
48018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48019 }
48020 arg1 = reinterpret_cast< wxSizer * >(argp1);
48021 arg2 = obj1;
48022 {
48023 arg3 = &temp3;
48024 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48025 }
48026 {
48027 PyThreadState* __tstate = wxPyBeginAllowThreads();
48028 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
48029 wxPyEndAllowThreads(__tstate);
48030 if (PyErr_Occurred()) SWIG_fail;
48031 }
48032 resultobj = SWIG_Py_Void();
48033 return resultobj;
48034 fail:
48035 return NULL;
48036 }
48037
48038
48039 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48040 PyObject *resultobj = 0;
48041 wxSizer *arg1 = (wxSizer *) 0 ;
48042 wxWindow *arg2 = (wxWindow *) 0 ;
48043 wxWindow *arg3 = (wxWindow *) 0 ;
48044 bool arg4 = (bool) false ;
48045 bool result;
48046 void *argp1 = 0 ;
48047 int res1 = 0 ;
48048 void *argp2 = 0 ;
48049 int res2 = 0 ;
48050 void *argp3 = 0 ;
48051 int res3 = 0 ;
48052 bool val4 ;
48053 int ecode4 = 0 ;
48054 PyObject * obj0 = 0 ;
48055 PyObject * obj1 = 0 ;
48056 PyObject * obj2 = 0 ;
48057 PyObject * obj3 = 0 ;
48058 char * kwnames[] = {
48059 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48060 };
48061
48062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48064 if (!SWIG_IsOK(res1)) {
48065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48066 }
48067 arg1 = reinterpret_cast< wxSizer * >(argp1);
48068 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48069 if (!SWIG_IsOK(res2)) {
48070 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48071 }
48072 arg2 = reinterpret_cast< wxWindow * >(argp2);
48073 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48074 if (!SWIG_IsOK(res3)) {
48075 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48076 }
48077 arg3 = reinterpret_cast< wxWindow * >(argp3);
48078 if (obj3) {
48079 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48080 if (!SWIG_IsOK(ecode4)) {
48081 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48082 }
48083 arg4 = static_cast< bool >(val4);
48084 }
48085 {
48086 PyThreadState* __tstate = wxPyBeginAllowThreads();
48087 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48088 wxPyEndAllowThreads(__tstate);
48089 if (PyErr_Occurred()) SWIG_fail;
48090 }
48091 {
48092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48093 }
48094 return resultobj;
48095 fail:
48096 return NULL;
48097 }
48098
48099
48100 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48101 PyObject *resultobj = 0;
48102 wxSizer *arg1 = (wxSizer *) 0 ;
48103 wxSizer *arg2 = (wxSizer *) 0 ;
48104 wxSizer *arg3 = (wxSizer *) 0 ;
48105 bool arg4 = (bool) false ;
48106 bool result;
48107 void *argp1 = 0 ;
48108 int res1 = 0 ;
48109 void *argp2 = 0 ;
48110 int res2 = 0 ;
48111 void *argp3 = 0 ;
48112 int res3 = 0 ;
48113 bool val4 ;
48114 int ecode4 = 0 ;
48115 PyObject * obj0 = 0 ;
48116 PyObject * obj1 = 0 ;
48117 PyObject * obj2 = 0 ;
48118 PyObject * obj3 = 0 ;
48119 char * kwnames[] = {
48120 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48121 };
48122
48123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48125 if (!SWIG_IsOK(res1)) {
48126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48127 }
48128 arg1 = reinterpret_cast< wxSizer * >(argp1);
48129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48130 if (!SWIG_IsOK(res2)) {
48131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48132 }
48133 arg2 = reinterpret_cast< wxSizer * >(argp2);
48134 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48135 if (!SWIG_IsOK(res3)) {
48136 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48137 }
48138 arg3 = reinterpret_cast< wxSizer * >(argp3);
48139 if (obj3) {
48140 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48141 if (!SWIG_IsOK(ecode4)) {
48142 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48143 }
48144 arg4 = static_cast< bool >(val4);
48145 }
48146 {
48147 PyThreadState* __tstate = wxPyBeginAllowThreads();
48148 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48149 wxPyEndAllowThreads(__tstate);
48150 if (PyErr_Occurred()) SWIG_fail;
48151 }
48152 {
48153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48154 }
48155 return resultobj;
48156 fail:
48157 return NULL;
48158 }
48159
48160
48161 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48162 PyObject *resultobj = 0;
48163 wxSizer *arg1 = (wxSizer *) 0 ;
48164 size_t arg2 ;
48165 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48166 bool result;
48167 void *argp1 = 0 ;
48168 int res1 = 0 ;
48169 size_t val2 ;
48170 int ecode2 = 0 ;
48171 void *argp3 = 0 ;
48172 int res3 = 0 ;
48173 PyObject * obj0 = 0 ;
48174 PyObject * obj1 = 0 ;
48175 PyObject * obj2 = 0 ;
48176 char * kwnames[] = {
48177 (char *) "self",(char *) "index",(char *) "newitem", NULL
48178 };
48179
48180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48182 if (!SWIG_IsOK(res1)) {
48183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48184 }
48185 arg1 = reinterpret_cast< wxSizer * >(argp1);
48186 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48187 if (!SWIG_IsOK(ecode2)) {
48188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48189 }
48190 arg2 = static_cast< size_t >(val2);
48191 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48192 if (!SWIG_IsOK(res3)) {
48193 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48194 }
48195 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48196 {
48197 PyThreadState* __tstate = wxPyBeginAllowThreads();
48198 result = (bool)(arg1)->Replace(arg2,arg3);
48199 wxPyEndAllowThreads(__tstate);
48200 if (PyErr_Occurred()) SWIG_fail;
48201 }
48202 {
48203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48204 }
48205 return resultobj;
48206 fail:
48207 return NULL;
48208 }
48209
48210
48211 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48212 PyObject *resultobj = 0;
48213 wxSizer *arg1 = (wxSizer *) 0 ;
48214 wxWindow *arg2 = (wxWindow *) 0 ;
48215 void *argp1 = 0 ;
48216 int res1 = 0 ;
48217 void *argp2 = 0 ;
48218 int res2 = 0 ;
48219 PyObject * obj0 = 0 ;
48220 PyObject * obj1 = 0 ;
48221 char * kwnames[] = {
48222 (char *) "self",(char *) "window", NULL
48223 };
48224
48225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48227 if (!SWIG_IsOK(res1)) {
48228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48229 }
48230 arg1 = reinterpret_cast< wxSizer * >(argp1);
48231 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48232 if (!SWIG_IsOK(res2)) {
48233 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48234 }
48235 arg2 = reinterpret_cast< wxWindow * >(argp2);
48236 {
48237 PyThreadState* __tstate = wxPyBeginAllowThreads();
48238 (arg1)->SetContainingWindow(arg2);
48239 wxPyEndAllowThreads(__tstate);
48240 if (PyErr_Occurred()) SWIG_fail;
48241 }
48242 resultobj = SWIG_Py_Void();
48243 return resultobj;
48244 fail:
48245 return NULL;
48246 }
48247
48248
48249 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48250 PyObject *resultobj = 0;
48251 wxSizer *arg1 = (wxSizer *) 0 ;
48252 wxWindow *result = 0 ;
48253 void *argp1 = 0 ;
48254 int res1 = 0 ;
48255 PyObject *swig_obj[1] ;
48256
48257 if (!args) SWIG_fail;
48258 swig_obj[0] = args;
48259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48260 if (!SWIG_IsOK(res1)) {
48261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48262 }
48263 arg1 = reinterpret_cast< wxSizer * >(argp1);
48264 {
48265 PyThreadState* __tstate = wxPyBeginAllowThreads();
48266 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48267 wxPyEndAllowThreads(__tstate);
48268 if (PyErr_Occurred()) SWIG_fail;
48269 }
48270 {
48271 resultobj = wxPyMake_wxObject(result, 0);
48272 }
48273 return resultobj;
48274 fail:
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48280 PyObject *resultobj = 0;
48281 wxSizer *arg1 = (wxSizer *) 0 ;
48282 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48283 wxSizerItem *result = 0 ;
48284 void *argp1 = 0 ;
48285 int res1 = 0 ;
48286 int res2 = 0 ;
48287 PyObject * obj0 = 0 ;
48288 PyObject * obj1 = 0 ;
48289 char * kwnames[] = {
48290 (char *) "self",(char *) "item", NULL
48291 };
48292
48293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48295 if (!SWIG_IsOK(res1)) {
48296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48297 }
48298 arg1 = reinterpret_cast< wxSizer * >(argp1);
48299 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48300 if (!SWIG_IsOK(res2)) {
48301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48302 }
48303 {
48304 PyThreadState* __tstate = wxPyBeginAllowThreads();
48305 result = (wxSizerItem *)(arg1)->Add(arg2);
48306 wxPyEndAllowThreads(__tstate);
48307 if (PyErr_Occurred()) SWIG_fail;
48308 }
48309 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48310 return resultobj;
48311 fail:
48312 return NULL;
48313 }
48314
48315
48316 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48317 PyObject *resultobj = 0;
48318 wxSizer *arg1 = (wxSizer *) 0 ;
48319 size_t arg2 ;
48320 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48321 wxSizerItem *result = 0 ;
48322 void *argp1 = 0 ;
48323 int res1 = 0 ;
48324 size_t val2 ;
48325 int ecode2 = 0 ;
48326 int res3 = 0 ;
48327 PyObject * obj0 = 0 ;
48328 PyObject * obj1 = 0 ;
48329 PyObject * obj2 = 0 ;
48330 char * kwnames[] = {
48331 (char *) "self",(char *) "index",(char *) "item", NULL
48332 };
48333
48334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48336 if (!SWIG_IsOK(res1)) {
48337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48338 }
48339 arg1 = reinterpret_cast< wxSizer * >(argp1);
48340 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48341 if (!SWIG_IsOK(ecode2)) {
48342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48343 }
48344 arg2 = static_cast< size_t >(val2);
48345 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48346 if (!SWIG_IsOK(res3)) {
48347 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48348 }
48349 {
48350 PyThreadState* __tstate = wxPyBeginAllowThreads();
48351 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48352 wxPyEndAllowThreads(__tstate);
48353 if (PyErr_Occurred()) SWIG_fail;
48354 }
48355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48356 return resultobj;
48357 fail:
48358 return NULL;
48359 }
48360
48361
48362 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48363 PyObject *resultobj = 0;
48364 wxSizer *arg1 = (wxSizer *) 0 ;
48365 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48366 wxSizerItem *result = 0 ;
48367 void *argp1 = 0 ;
48368 int res1 = 0 ;
48369 int res2 = 0 ;
48370 PyObject * obj0 = 0 ;
48371 PyObject * obj1 = 0 ;
48372 char * kwnames[] = {
48373 (char *) "self",(char *) "item", NULL
48374 };
48375
48376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48378 if (!SWIG_IsOK(res1)) {
48379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48380 }
48381 arg1 = reinterpret_cast< wxSizer * >(argp1);
48382 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48383 if (!SWIG_IsOK(res2)) {
48384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48385 }
48386 {
48387 PyThreadState* __tstate = wxPyBeginAllowThreads();
48388 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48389 wxPyEndAllowThreads(__tstate);
48390 if (PyErr_Occurred()) SWIG_fail;
48391 }
48392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48393 return resultobj;
48394 fail:
48395 return NULL;
48396 }
48397
48398
48399 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48400 PyObject *resultobj = 0;
48401 wxSizer *arg1 = (wxSizer *) 0 ;
48402 int arg2 ;
48403 int arg3 ;
48404 int arg4 ;
48405 int arg5 ;
48406 void *argp1 = 0 ;
48407 int res1 = 0 ;
48408 int val2 ;
48409 int ecode2 = 0 ;
48410 int val3 ;
48411 int ecode3 = 0 ;
48412 int val4 ;
48413 int ecode4 = 0 ;
48414 int val5 ;
48415 int ecode5 = 0 ;
48416 PyObject * obj0 = 0 ;
48417 PyObject * obj1 = 0 ;
48418 PyObject * obj2 = 0 ;
48419 PyObject * obj3 = 0 ;
48420 PyObject * obj4 = 0 ;
48421 char * kwnames[] = {
48422 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48423 };
48424
48425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48427 if (!SWIG_IsOK(res1)) {
48428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48429 }
48430 arg1 = reinterpret_cast< wxSizer * >(argp1);
48431 ecode2 = SWIG_AsVal_int(obj1, &val2);
48432 if (!SWIG_IsOK(ecode2)) {
48433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48434 }
48435 arg2 = static_cast< int >(val2);
48436 ecode3 = SWIG_AsVal_int(obj2, &val3);
48437 if (!SWIG_IsOK(ecode3)) {
48438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48439 }
48440 arg3 = static_cast< int >(val3);
48441 ecode4 = SWIG_AsVal_int(obj3, &val4);
48442 if (!SWIG_IsOK(ecode4)) {
48443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48444 }
48445 arg4 = static_cast< int >(val4);
48446 ecode5 = SWIG_AsVal_int(obj4, &val5);
48447 if (!SWIG_IsOK(ecode5)) {
48448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48449 }
48450 arg5 = static_cast< int >(val5);
48451 {
48452 PyThreadState* __tstate = wxPyBeginAllowThreads();
48453 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48454 wxPyEndAllowThreads(__tstate);
48455 if (PyErr_Occurred()) SWIG_fail;
48456 }
48457 resultobj = SWIG_Py_Void();
48458 return resultobj;
48459 fail:
48460 return NULL;
48461 }
48462
48463
48464 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48465 PyObject *resultobj = 0;
48466 wxSizer *arg1 = (wxSizer *) 0 ;
48467 wxSize *arg2 = 0 ;
48468 void *argp1 = 0 ;
48469 int res1 = 0 ;
48470 wxSize temp2 ;
48471 PyObject * obj0 = 0 ;
48472 PyObject * obj1 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "self",(char *) "size", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48479 if (!SWIG_IsOK(res1)) {
48480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48481 }
48482 arg1 = reinterpret_cast< wxSizer * >(argp1);
48483 {
48484 arg2 = &temp2;
48485 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48486 }
48487 {
48488 PyThreadState* __tstate = wxPyBeginAllowThreads();
48489 (arg1)->SetMinSize((wxSize const &)*arg2);
48490 wxPyEndAllowThreads(__tstate);
48491 if (PyErr_Occurred()) SWIG_fail;
48492 }
48493 resultobj = SWIG_Py_Void();
48494 return resultobj;
48495 fail:
48496 return NULL;
48497 }
48498
48499
48500 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48501 PyObject *resultobj = 0;
48502 wxSizer *arg1 = (wxSizer *) 0 ;
48503 wxSize result;
48504 void *argp1 = 0 ;
48505 int res1 = 0 ;
48506 PyObject *swig_obj[1] ;
48507
48508 if (!args) SWIG_fail;
48509 swig_obj[0] = args;
48510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48511 if (!SWIG_IsOK(res1)) {
48512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48513 }
48514 arg1 = reinterpret_cast< wxSizer * >(argp1);
48515 {
48516 PyThreadState* __tstate = wxPyBeginAllowThreads();
48517 result = (arg1)->GetSize();
48518 wxPyEndAllowThreads(__tstate);
48519 if (PyErr_Occurred()) SWIG_fail;
48520 }
48521 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48522 return resultobj;
48523 fail:
48524 return NULL;
48525 }
48526
48527
48528 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48529 PyObject *resultobj = 0;
48530 wxSizer *arg1 = (wxSizer *) 0 ;
48531 wxPoint result;
48532 void *argp1 = 0 ;
48533 int res1 = 0 ;
48534 PyObject *swig_obj[1] ;
48535
48536 if (!args) SWIG_fail;
48537 swig_obj[0] = args;
48538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48539 if (!SWIG_IsOK(res1)) {
48540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48541 }
48542 arg1 = reinterpret_cast< wxSizer * >(argp1);
48543 {
48544 PyThreadState* __tstate = wxPyBeginAllowThreads();
48545 result = (arg1)->GetPosition();
48546 wxPyEndAllowThreads(__tstate);
48547 if (PyErr_Occurred()) SWIG_fail;
48548 }
48549 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48550 return resultobj;
48551 fail:
48552 return NULL;
48553 }
48554
48555
48556 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48557 PyObject *resultobj = 0;
48558 wxSizer *arg1 = (wxSizer *) 0 ;
48559 wxSize result;
48560 void *argp1 = 0 ;
48561 int res1 = 0 ;
48562 PyObject *swig_obj[1] ;
48563
48564 if (!args) SWIG_fail;
48565 swig_obj[0] = args;
48566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48567 if (!SWIG_IsOK(res1)) {
48568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48569 }
48570 arg1 = reinterpret_cast< wxSizer * >(argp1);
48571 {
48572 PyThreadState* __tstate = wxPyBeginAllowThreads();
48573 result = (arg1)->GetMinSize();
48574 wxPyEndAllowThreads(__tstate);
48575 if (PyErr_Occurred()) SWIG_fail;
48576 }
48577 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48578 return resultobj;
48579 fail:
48580 return NULL;
48581 }
48582
48583
48584 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48585 PyObject *resultobj = 0;
48586 wxSizer *arg1 = (wxSizer *) 0 ;
48587 void *argp1 = 0 ;
48588 int res1 = 0 ;
48589 PyObject *swig_obj[1] ;
48590
48591 if (!args) SWIG_fail;
48592 swig_obj[0] = args;
48593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48594 if (!SWIG_IsOK(res1)) {
48595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48596 }
48597 arg1 = reinterpret_cast< wxSizer * >(argp1);
48598 {
48599 PyThreadState* __tstate = wxPyBeginAllowThreads();
48600 (arg1)->RecalcSizes();
48601 wxPyEndAllowThreads(__tstate);
48602 if (PyErr_Occurred()) SWIG_fail;
48603 }
48604 resultobj = SWIG_Py_Void();
48605 return resultobj;
48606 fail:
48607 return NULL;
48608 }
48609
48610
48611 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48612 PyObject *resultobj = 0;
48613 wxSizer *arg1 = (wxSizer *) 0 ;
48614 wxSize result;
48615 void *argp1 = 0 ;
48616 int res1 = 0 ;
48617 PyObject *swig_obj[1] ;
48618
48619 if (!args) SWIG_fail;
48620 swig_obj[0] = args;
48621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48622 if (!SWIG_IsOK(res1)) {
48623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48624 }
48625 arg1 = reinterpret_cast< wxSizer * >(argp1);
48626 {
48627 PyThreadState* __tstate = wxPyBeginAllowThreads();
48628 result = (arg1)->CalcMin();
48629 wxPyEndAllowThreads(__tstate);
48630 if (PyErr_Occurred()) SWIG_fail;
48631 }
48632 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48633 return resultobj;
48634 fail:
48635 return NULL;
48636 }
48637
48638
48639 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48640 PyObject *resultobj = 0;
48641 wxSizer *arg1 = (wxSizer *) 0 ;
48642 void *argp1 = 0 ;
48643 int res1 = 0 ;
48644 PyObject *swig_obj[1] ;
48645
48646 if (!args) SWIG_fail;
48647 swig_obj[0] = args;
48648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48649 if (!SWIG_IsOK(res1)) {
48650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48651 }
48652 arg1 = reinterpret_cast< wxSizer * >(argp1);
48653 {
48654 PyThreadState* __tstate = wxPyBeginAllowThreads();
48655 (arg1)->Layout();
48656 wxPyEndAllowThreads(__tstate);
48657 if (PyErr_Occurred()) SWIG_fail;
48658 }
48659 resultobj = SWIG_Py_Void();
48660 return resultobj;
48661 fail:
48662 return NULL;
48663 }
48664
48665
48666 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48667 PyObject *resultobj = 0;
48668 wxSizer *arg1 = (wxSizer *) 0 ;
48669 wxWindow *arg2 = (wxWindow *) 0 ;
48670 wxSize result;
48671 void *argp1 = 0 ;
48672 int res1 = 0 ;
48673 void *argp2 = 0 ;
48674 int res2 = 0 ;
48675 PyObject * obj0 = 0 ;
48676 PyObject * obj1 = 0 ;
48677 char * kwnames[] = {
48678 (char *) "self",(char *) "window", NULL
48679 };
48680
48681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48683 if (!SWIG_IsOK(res1)) {
48684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48685 }
48686 arg1 = reinterpret_cast< wxSizer * >(argp1);
48687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48688 if (!SWIG_IsOK(res2)) {
48689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48690 }
48691 arg2 = reinterpret_cast< wxWindow * >(argp2);
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 result = (arg1)->Fit(arg2);
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48699 return resultobj;
48700 fail:
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48706 PyObject *resultobj = 0;
48707 wxSizer *arg1 = (wxSizer *) 0 ;
48708 wxWindow *arg2 = (wxWindow *) 0 ;
48709 void *argp1 = 0 ;
48710 int res1 = 0 ;
48711 void *argp2 = 0 ;
48712 int res2 = 0 ;
48713 PyObject * obj0 = 0 ;
48714 PyObject * obj1 = 0 ;
48715 char * kwnames[] = {
48716 (char *) "self",(char *) "window", NULL
48717 };
48718
48719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48721 if (!SWIG_IsOK(res1)) {
48722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48723 }
48724 arg1 = reinterpret_cast< wxSizer * >(argp1);
48725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48726 if (!SWIG_IsOK(res2)) {
48727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48728 }
48729 arg2 = reinterpret_cast< wxWindow * >(argp2);
48730 {
48731 PyThreadState* __tstate = wxPyBeginAllowThreads();
48732 (arg1)->FitInside(arg2);
48733 wxPyEndAllowThreads(__tstate);
48734 if (PyErr_Occurred()) SWIG_fail;
48735 }
48736 resultobj = SWIG_Py_Void();
48737 return resultobj;
48738 fail:
48739 return NULL;
48740 }
48741
48742
48743 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48744 PyObject *resultobj = 0;
48745 wxSizer *arg1 = (wxSizer *) 0 ;
48746 wxWindow *arg2 = (wxWindow *) 0 ;
48747 void *argp1 = 0 ;
48748 int res1 = 0 ;
48749 void *argp2 = 0 ;
48750 int res2 = 0 ;
48751 PyObject * obj0 = 0 ;
48752 PyObject * obj1 = 0 ;
48753 char * kwnames[] = {
48754 (char *) "self",(char *) "window", NULL
48755 };
48756
48757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48759 if (!SWIG_IsOK(res1)) {
48760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48761 }
48762 arg1 = reinterpret_cast< wxSizer * >(argp1);
48763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48764 if (!SWIG_IsOK(res2)) {
48765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48766 }
48767 arg2 = reinterpret_cast< wxWindow * >(argp2);
48768 {
48769 PyThreadState* __tstate = wxPyBeginAllowThreads();
48770 (arg1)->SetSizeHints(arg2);
48771 wxPyEndAllowThreads(__tstate);
48772 if (PyErr_Occurred()) SWIG_fail;
48773 }
48774 resultobj = SWIG_Py_Void();
48775 return resultobj;
48776 fail:
48777 return NULL;
48778 }
48779
48780
48781 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48782 PyObject *resultobj = 0;
48783 wxSizer *arg1 = (wxSizer *) 0 ;
48784 wxWindow *arg2 = (wxWindow *) 0 ;
48785 void *argp1 = 0 ;
48786 int res1 = 0 ;
48787 void *argp2 = 0 ;
48788 int res2 = 0 ;
48789 PyObject * obj0 = 0 ;
48790 PyObject * obj1 = 0 ;
48791 char * kwnames[] = {
48792 (char *) "self",(char *) "window", NULL
48793 };
48794
48795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48797 if (!SWIG_IsOK(res1)) {
48798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48799 }
48800 arg1 = reinterpret_cast< wxSizer * >(argp1);
48801 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48802 if (!SWIG_IsOK(res2)) {
48803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48804 }
48805 arg2 = reinterpret_cast< wxWindow * >(argp2);
48806 {
48807 PyThreadState* __tstate = wxPyBeginAllowThreads();
48808 (arg1)->SetVirtualSizeHints(arg2);
48809 wxPyEndAllowThreads(__tstate);
48810 if (PyErr_Occurred()) SWIG_fail;
48811 }
48812 resultobj = SWIG_Py_Void();
48813 return resultobj;
48814 fail:
48815 return NULL;
48816 }
48817
48818
48819 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48820 PyObject *resultobj = 0;
48821 wxSizer *arg1 = (wxSizer *) 0 ;
48822 bool arg2 = (bool) false ;
48823 void *argp1 = 0 ;
48824 int res1 = 0 ;
48825 bool val2 ;
48826 int ecode2 = 0 ;
48827 PyObject * obj0 = 0 ;
48828 PyObject * obj1 = 0 ;
48829 char * kwnames[] = {
48830 (char *) "self",(char *) "deleteWindows", NULL
48831 };
48832
48833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48835 if (!SWIG_IsOK(res1)) {
48836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48837 }
48838 arg1 = reinterpret_cast< wxSizer * >(argp1);
48839 if (obj1) {
48840 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48841 if (!SWIG_IsOK(ecode2)) {
48842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48843 }
48844 arg2 = static_cast< bool >(val2);
48845 }
48846 {
48847 PyThreadState* __tstate = wxPyBeginAllowThreads();
48848 (arg1)->Clear(arg2);
48849 wxPyEndAllowThreads(__tstate);
48850 if (PyErr_Occurred()) SWIG_fail;
48851 }
48852 resultobj = SWIG_Py_Void();
48853 return resultobj;
48854 fail:
48855 return NULL;
48856 }
48857
48858
48859 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48860 PyObject *resultobj = 0;
48861 wxSizer *arg1 = (wxSizer *) 0 ;
48862 void *argp1 = 0 ;
48863 int res1 = 0 ;
48864 PyObject *swig_obj[1] ;
48865
48866 if (!args) SWIG_fail;
48867 swig_obj[0] = args;
48868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48869 if (!SWIG_IsOK(res1)) {
48870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48871 }
48872 arg1 = reinterpret_cast< wxSizer * >(argp1);
48873 {
48874 PyThreadState* __tstate = wxPyBeginAllowThreads();
48875 (arg1)->DeleteWindows();
48876 wxPyEndAllowThreads(__tstate);
48877 if (PyErr_Occurred()) SWIG_fail;
48878 }
48879 resultobj = SWIG_Py_Void();
48880 return resultobj;
48881 fail:
48882 return NULL;
48883 }
48884
48885
48886 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48887 PyObject *resultobj = 0;
48888 wxSizer *arg1 = (wxSizer *) 0 ;
48889 PyObject *result = 0 ;
48890 void *argp1 = 0 ;
48891 int res1 = 0 ;
48892 PyObject *swig_obj[1] ;
48893
48894 if (!args) SWIG_fail;
48895 swig_obj[0] = args;
48896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48897 if (!SWIG_IsOK(res1)) {
48898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48899 }
48900 arg1 = reinterpret_cast< wxSizer * >(argp1);
48901 {
48902 PyThreadState* __tstate = wxPyBeginAllowThreads();
48903 result = (PyObject *)wxSizer_GetChildren(arg1);
48904 wxPyEndAllowThreads(__tstate);
48905 if (PyErr_Occurred()) SWIG_fail;
48906 }
48907 resultobj = result;
48908 return resultobj;
48909 fail:
48910 return NULL;
48911 }
48912
48913
48914 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48915 PyObject *resultobj = 0;
48916 wxSizer *arg1 = (wxSizer *) 0 ;
48917 PyObject *arg2 = (PyObject *) 0 ;
48918 bool arg3 = (bool) true ;
48919 bool arg4 = (bool) false ;
48920 bool result;
48921 void *argp1 = 0 ;
48922 int res1 = 0 ;
48923 bool val3 ;
48924 int ecode3 = 0 ;
48925 bool val4 ;
48926 int ecode4 = 0 ;
48927 PyObject * obj0 = 0 ;
48928 PyObject * obj1 = 0 ;
48929 PyObject * obj2 = 0 ;
48930 PyObject * obj3 = 0 ;
48931 char * kwnames[] = {
48932 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48933 };
48934
48935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48937 if (!SWIG_IsOK(res1)) {
48938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48939 }
48940 arg1 = reinterpret_cast< wxSizer * >(argp1);
48941 arg2 = obj1;
48942 if (obj2) {
48943 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48944 if (!SWIG_IsOK(ecode3)) {
48945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48946 }
48947 arg3 = static_cast< bool >(val3);
48948 }
48949 if (obj3) {
48950 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48951 if (!SWIG_IsOK(ecode4)) {
48952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48953 }
48954 arg4 = static_cast< bool >(val4);
48955 }
48956 {
48957 PyThreadState* __tstate = wxPyBeginAllowThreads();
48958 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48959 wxPyEndAllowThreads(__tstate);
48960 if (PyErr_Occurred()) SWIG_fail;
48961 }
48962 {
48963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48964 }
48965 return resultobj;
48966 fail:
48967 return NULL;
48968 }
48969
48970
48971 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48972 PyObject *resultobj = 0;
48973 wxSizer *arg1 = (wxSizer *) 0 ;
48974 PyObject *arg2 = (PyObject *) 0 ;
48975 bool result;
48976 void *argp1 = 0 ;
48977 int res1 = 0 ;
48978 PyObject * obj0 = 0 ;
48979 PyObject * obj1 = 0 ;
48980 char * kwnames[] = {
48981 (char *) "self",(char *) "item", NULL
48982 };
48983
48984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48986 if (!SWIG_IsOK(res1)) {
48987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48988 }
48989 arg1 = reinterpret_cast< wxSizer * >(argp1);
48990 arg2 = obj1;
48991 {
48992 PyThreadState* __tstate = wxPyBeginAllowThreads();
48993 result = (bool)wxSizer_IsShown(arg1,arg2);
48994 wxPyEndAllowThreads(__tstate);
48995 if (PyErr_Occurred()) SWIG_fail;
48996 }
48997 {
48998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48999 }
49000 return resultobj;
49001 fail:
49002 return NULL;
49003 }
49004
49005
49006 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49007 PyObject *resultobj = 0;
49008 wxSizer *arg1 = (wxSizer *) 0 ;
49009 bool arg2 ;
49010 void *argp1 = 0 ;
49011 int res1 = 0 ;
49012 bool val2 ;
49013 int ecode2 = 0 ;
49014 PyObject * obj0 = 0 ;
49015 PyObject * obj1 = 0 ;
49016 char * kwnames[] = {
49017 (char *) "self",(char *) "show", NULL
49018 };
49019
49020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
49021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49022 if (!SWIG_IsOK(res1)) {
49023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
49024 }
49025 arg1 = reinterpret_cast< wxSizer * >(argp1);
49026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49027 if (!SWIG_IsOK(ecode2)) {
49028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
49029 }
49030 arg2 = static_cast< bool >(val2);
49031 {
49032 PyThreadState* __tstate = wxPyBeginAllowThreads();
49033 (arg1)->ShowItems(arg2);
49034 wxPyEndAllowThreads(__tstate);
49035 if (PyErr_Occurred()) SWIG_fail;
49036 }
49037 resultobj = SWIG_Py_Void();
49038 return resultobj;
49039 fail:
49040 return NULL;
49041 }
49042
49043
49044 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49045 PyObject *obj;
49046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49047 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49048 return SWIG_Py_Void();
49049 }
49050
49051 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49052 PyObject *resultobj = 0;
49053 wxPySizer *result = 0 ;
49054
49055 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49056 {
49057 PyThreadState* __tstate = wxPyBeginAllowThreads();
49058 result = (wxPySizer *)new wxPySizer();
49059 wxPyEndAllowThreads(__tstate);
49060 if (PyErr_Occurred()) SWIG_fail;
49061 }
49062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49063 return resultobj;
49064 fail:
49065 return NULL;
49066 }
49067
49068
49069 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49070 PyObject *resultobj = 0;
49071 wxPySizer *arg1 = (wxPySizer *) 0 ;
49072 PyObject *arg2 = (PyObject *) 0 ;
49073 PyObject *arg3 = (PyObject *) 0 ;
49074 void *argp1 = 0 ;
49075 int res1 = 0 ;
49076 PyObject * obj0 = 0 ;
49077 PyObject * obj1 = 0 ;
49078 PyObject * obj2 = 0 ;
49079 char * kwnames[] = {
49080 (char *) "self",(char *) "self",(char *) "_class", NULL
49081 };
49082
49083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49085 if (!SWIG_IsOK(res1)) {
49086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49087 }
49088 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49089 arg2 = obj1;
49090 arg3 = obj2;
49091 {
49092 PyThreadState* __tstate = wxPyBeginAllowThreads();
49093 (arg1)->_setCallbackInfo(arg2,arg3);
49094 wxPyEndAllowThreads(__tstate);
49095 if (PyErr_Occurred()) SWIG_fail;
49096 }
49097 resultobj = SWIG_Py_Void();
49098 return resultobj;
49099 fail:
49100 return NULL;
49101 }
49102
49103
49104 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49105 PyObject *obj;
49106 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49107 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49108 return SWIG_Py_Void();
49109 }
49110
49111 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49112 return SWIG_Python_InitShadowInstance(args);
49113 }
49114
49115 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49116 PyObject *resultobj = 0;
49117 int arg1 = (int) wxHORIZONTAL ;
49118 wxBoxSizer *result = 0 ;
49119 int val1 ;
49120 int ecode1 = 0 ;
49121 PyObject * obj0 = 0 ;
49122 char * kwnames[] = {
49123 (char *) "orient", NULL
49124 };
49125
49126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49127 if (obj0) {
49128 ecode1 = SWIG_AsVal_int(obj0, &val1);
49129 if (!SWIG_IsOK(ecode1)) {
49130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49131 }
49132 arg1 = static_cast< int >(val1);
49133 }
49134 {
49135 PyThreadState* __tstate = wxPyBeginAllowThreads();
49136 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49137 wxPyEndAllowThreads(__tstate);
49138 if (PyErr_Occurred()) SWIG_fail;
49139 }
49140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49141 return resultobj;
49142 fail:
49143 return NULL;
49144 }
49145
49146
49147 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49148 PyObject *resultobj = 0;
49149 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49150 int result;
49151 void *argp1 = 0 ;
49152 int res1 = 0 ;
49153 PyObject *swig_obj[1] ;
49154
49155 if (!args) SWIG_fail;
49156 swig_obj[0] = args;
49157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49158 if (!SWIG_IsOK(res1)) {
49159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49160 }
49161 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49162 {
49163 PyThreadState* __tstate = wxPyBeginAllowThreads();
49164 result = (int)(arg1)->GetOrientation();
49165 wxPyEndAllowThreads(__tstate);
49166 if (PyErr_Occurred()) SWIG_fail;
49167 }
49168 resultobj = SWIG_From_int(static_cast< int >(result));
49169 return resultobj;
49170 fail:
49171 return NULL;
49172 }
49173
49174
49175 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49176 PyObject *resultobj = 0;
49177 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49178 int arg2 ;
49179 void *argp1 = 0 ;
49180 int res1 = 0 ;
49181 int val2 ;
49182 int ecode2 = 0 ;
49183 PyObject * obj0 = 0 ;
49184 PyObject * obj1 = 0 ;
49185 char * kwnames[] = {
49186 (char *) "self",(char *) "orient", NULL
49187 };
49188
49189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49191 if (!SWIG_IsOK(res1)) {
49192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49193 }
49194 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49195 ecode2 = SWIG_AsVal_int(obj1, &val2);
49196 if (!SWIG_IsOK(ecode2)) {
49197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49198 }
49199 arg2 = static_cast< int >(val2);
49200 {
49201 PyThreadState* __tstate = wxPyBeginAllowThreads();
49202 (arg1)->SetOrientation(arg2);
49203 wxPyEndAllowThreads(__tstate);
49204 if (PyErr_Occurred()) SWIG_fail;
49205 }
49206 resultobj = SWIG_Py_Void();
49207 return resultobj;
49208 fail:
49209 return NULL;
49210 }
49211
49212
49213 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49214 PyObject *obj;
49215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49216 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49217 return SWIG_Py_Void();
49218 }
49219
49220 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49221 return SWIG_Python_InitShadowInstance(args);
49222 }
49223
49224 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49225 PyObject *resultobj = 0;
49226 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49227 int arg2 = (int) wxHORIZONTAL ;
49228 wxStaticBoxSizer *result = 0 ;
49229 void *argp1 = 0 ;
49230 int res1 = 0 ;
49231 int val2 ;
49232 int ecode2 = 0 ;
49233 PyObject * obj0 = 0 ;
49234 PyObject * obj1 = 0 ;
49235 char * kwnames[] = {
49236 (char *) "box",(char *) "orient", NULL
49237 };
49238
49239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49241 if (!SWIG_IsOK(res1)) {
49242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49243 }
49244 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49245 if (obj1) {
49246 ecode2 = SWIG_AsVal_int(obj1, &val2);
49247 if (!SWIG_IsOK(ecode2)) {
49248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49249 }
49250 arg2 = static_cast< int >(val2);
49251 }
49252 {
49253 PyThreadState* __tstate = wxPyBeginAllowThreads();
49254 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49255 wxPyEndAllowThreads(__tstate);
49256 if (PyErr_Occurred()) SWIG_fail;
49257 }
49258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49259 return resultobj;
49260 fail:
49261 return NULL;
49262 }
49263
49264
49265 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49266 PyObject *resultobj = 0;
49267 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49268 wxStaticBox *result = 0 ;
49269 void *argp1 = 0 ;
49270 int res1 = 0 ;
49271 PyObject *swig_obj[1] ;
49272
49273 if (!args) SWIG_fail;
49274 swig_obj[0] = args;
49275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49276 if (!SWIG_IsOK(res1)) {
49277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49278 }
49279 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49280 {
49281 PyThreadState* __tstate = wxPyBeginAllowThreads();
49282 result = (wxStaticBox *)(arg1)->GetStaticBox();
49283 wxPyEndAllowThreads(__tstate);
49284 if (PyErr_Occurred()) SWIG_fail;
49285 }
49286 {
49287 resultobj = wxPyMake_wxObject(result, (bool)0);
49288 }
49289 return resultobj;
49290 fail:
49291 return NULL;
49292 }
49293
49294
49295 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49296 PyObject *obj;
49297 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49298 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49299 return SWIG_Py_Void();
49300 }
49301
49302 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49303 return SWIG_Python_InitShadowInstance(args);
49304 }
49305
49306 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49307 PyObject *resultobj = 0;
49308 int arg1 = (int) 1 ;
49309 int arg2 = (int) 0 ;
49310 int arg3 = (int) 0 ;
49311 int arg4 = (int) 0 ;
49312 wxGridSizer *result = 0 ;
49313 int val1 ;
49314 int ecode1 = 0 ;
49315 int val2 ;
49316 int ecode2 = 0 ;
49317 int val3 ;
49318 int ecode3 = 0 ;
49319 int val4 ;
49320 int ecode4 = 0 ;
49321 PyObject * obj0 = 0 ;
49322 PyObject * obj1 = 0 ;
49323 PyObject * obj2 = 0 ;
49324 PyObject * obj3 = 0 ;
49325 char * kwnames[] = {
49326 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49327 };
49328
49329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49330 if (obj0) {
49331 ecode1 = SWIG_AsVal_int(obj0, &val1);
49332 if (!SWIG_IsOK(ecode1)) {
49333 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49334 }
49335 arg1 = static_cast< int >(val1);
49336 }
49337 if (obj1) {
49338 ecode2 = SWIG_AsVal_int(obj1, &val2);
49339 if (!SWIG_IsOK(ecode2)) {
49340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49341 }
49342 arg2 = static_cast< int >(val2);
49343 }
49344 if (obj2) {
49345 ecode3 = SWIG_AsVal_int(obj2, &val3);
49346 if (!SWIG_IsOK(ecode3)) {
49347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49348 }
49349 arg3 = static_cast< int >(val3);
49350 }
49351 if (obj3) {
49352 ecode4 = SWIG_AsVal_int(obj3, &val4);
49353 if (!SWIG_IsOK(ecode4)) {
49354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49355 }
49356 arg4 = static_cast< int >(val4);
49357 }
49358 {
49359 PyThreadState* __tstate = wxPyBeginAllowThreads();
49360 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49361 wxPyEndAllowThreads(__tstate);
49362 if (PyErr_Occurred()) SWIG_fail;
49363 }
49364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49365 return resultobj;
49366 fail:
49367 return NULL;
49368 }
49369
49370
49371 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49372 PyObject *resultobj = 0;
49373 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49374 int arg2 ;
49375 void *argp1 = 0 ;
49376 int res1 = 0 ;
49377 int val2 ;
49378 int ecode2 = 0 ;
49379 PyObject * obj0 = 0 ;
49380 PyObject * obj1 = 0 ;
49381 char * kwnames[] = {
49382 (char *) "self",(char *) "cols", NULL
49383 };
49384
49385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49387 if (!SWIG_IsOK(res1)) {
49388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49389 }
49390 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49391 ecode2 = SWIG_AsVal_int(obj1, &val2);
49392 if (!SWIG_IsOK(ecode2)) {
49393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49394 }
49395 arg2 = static_cast< int >(val2);
49396 {
49397 PyThreadState* __tstate = wxPyBeginAllowThreads();
49398 (arg1)->SetCols(arg2);
49399 wxPyEndAllowThreads(__tstate);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 resultobj = SWIG_Py_Void();
49403 return resultobj;
49404 fail:
49405 return NULL;
49406 }
49407
49408
49409 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49410 PyObject *resultobj = 0;
49411 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49412 int arg2 ;
49413 void *argp1 = 0 ;
49414 int res1 = 0 ;
49415 int val2 ;
49416 int ecode2 = 0 ;
49417 PyObject * obj0 = 0 ;
49418 PyObject * obj1 = 0 ;
49419 char * kwnames[] = {
49420 (char *) "self",(char *) "rows", NULL
49421 };
49422
49423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49425 if (!SWIG_IsOK(res1)) {
49426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49427 }
49428 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49429 ecode2 = SWIG_AsVal_int(obj1, &val2);
49430 if (!SWIG_IsOK(ecode2)) {
49431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49432 }
49433 arg2 = static_cast< int >(val2);
49434 {
49435 PyThreadState* __tstate = wxPyBeginAllowThreads();
49436 (arg1)->SetRows(arg2);
49437 wxPyEndAllowThreads(__tstate);
49438 if (PyErr_Occurred()) SWIG_fail;
49439 }
49440 resultobj = SWIG_Py_Void();
49441 return resultobj;
49442 fail:
49443 return NULL;
49444 }
49445
49446
49447 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49448 PyObject *resultobj = 0;
49449 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49450 int arg2 ;
49451 void *argp1 = 0 ;
49452 int res1 = 0 ;
49453 int val2 ;
49454 int ecode2 = 0 ;
49455 PyObject * obj0 = 0 ;
49456 PyObject * obj1 = 0 ;
49457 char * kwnames[] = {
49458 (char *) "self",(char *) "gap", NULL
49459 };
49460
49461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49463 if (!SWIG_IsOK(res1)) {
49464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49465 }
49466 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49467 ecode2 = SWIG_AsVal_int(obj1, &val2);
49468 if (!SWIG_IsOK(ecode2)) {
49469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49470 }
49471 arg2 = static_cast< int >(val2);
49472 {
49473 PyThreadState* __tstate = wxPyBeginAllowThreads();
49474 (arg1)->SetVGap(arg2);
49475 wxPyEndAllowThreads(__tstate);
49476 if (PyErr_Occurred()) SWIG_fail;
49477 }
49478 resultobj = SWIG_Py_Void();
49479 return resultobj;
49480 fail:
49481 return NULL;
49482 }
49483
49484
49485 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49486 PyObject *resultobj = 0;
49487 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49488 int arg2 ;
49489 void *argp1 = 0 ;
49490 int res1 = 0 ;
49491 int val2 ;
49492 int ecode2 = 0 ;
49493 PyObject * obj0 = 0 ;
49494 PyObject * obj1 = 0 ;
49495 char * kwnames[] = {
49496 (char *) "self",(char *) "gap", NULL
49497 };
49498
49499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49501 if (!SWIG_IsOK(res1)) {
49502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49503 }
49504 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49505 ecode2 = SWIG_AsVal_int(obj1, &val2);
49506 if (!SWIG_IsOK(ecode2)) {
49507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49508 }
49509 arg2 = static_cast< int >(val2);
49510 {
49511 PyThreadState* __tstate = wxPyBeginAllowThreads();
49512 (arg1)->SetHGap(arg2);
49513 wxPyEndAllowThreads(__tstate);
49514 if (PyErr_Occurred()) SWIG_fail;
49515 }
49516 resultobj = SWIG_Py_Void();
49517 return resultobj;
49518 fail:
49519 return NULL;
49520 }
49521
49522
49523 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49524 PyObject *resultobj = 0;
49525 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49526 int result;
49527 void *argp1 = 0 ;
49528 int res1 = 0 ;
49529 PyObject *swig_obj[1] ;
49530
49531 if (!args) SWIG_fail;
49532 swig_obj[0] = args;
49533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49534 if (!SWIG_IsOK(res1)) {
49535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49536 }
49537 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49538 {
49539 PyThreadState* __tstate = wxPyBeginAllowThreads();
49540 result = (int)(arg1)->GetCols();
49541 wxPyEndAllowThreads(__tstate);
49542 if (PyErr_Occurred()) SWIG_fail;
49543 }
49544 resultobj = SWIG_From_int(static_cast< int >(result));
49545 return resultobj;
49546 fail:
49547 return NULL;
49548 }
49549
49550
49551 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49552 PyObject *resultobj = 0;
49553 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49554 int result;
49555 void *argp1 = 0 ;
49556 int res1 = 0 ;
49557 PyObject *swig_obj[1] ;
49558
49559 if (!args) SWIG_fail;
49560 swig_obj[0] = args;
49561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49562 if (!SWIG_IsOK(res1)) {
49563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49564 }
49565 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49566 {
49567 PyThreadState* __tstate = wxPyBeginAllowThreads();
49568 result = (int)(arg1)->GetRows();
49569 wxPyEndAllowThreads(__tstate);
49570 if (PyErr_Occurred()) SWIG_fail;
49571 }
49572 resultobj = SWIG_From_int(static_cast< int >(result));
49573 return resultobj;
49574 fail:
49575 return NULL;
49576 }
49577
49578
49579 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49580 PyObject *resultobj = 0;
49581 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49582 int result;
49583 void *argp1 = 0 ;
49584 int res1 = 0 ;
49585 PyObject *swig_obj[1] ;
49586
49587 if (!args) SWIG_fail;
49588 swig_obj[0] = args;
49589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49590 if (!SWIG_IsOK(res1)) {
49591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49592 }
49593 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49594 {
49595 PyThreadState* __tstate = wxPyBeginAllowThreads();
49596 result = (int)(arg1)->GetVGap();
49597 wxPyEndAllowThreads(__tstate);
49598 if (PyErr_Occurred()) SWIG_fail;
49599 }
49600 resultobj = SWIG_From_int(static_cast< int >(result));
49601 return resultobj;
49602 fail:
49603 return NULL;
49604 }
49605
49606
49607 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49608 PyObject *resultobj = 0;
49609 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49610 int result;
49611 void *argp1 = 0 ;
49612 int res1 = 0 ;
49613 PyObject *swig_obj[1] ;
49614
49615 if (!args) SWIG_fail;
49616 swig_obj[0] = args;
49617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49618 if (!SWIG_IsOK(res1)) {
49619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49620 }
49621 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 result = (int)(arg1)->GetHGap();
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_From_int(static_cast< int >(result));
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49636 PyObject *obj;
49637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49638 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49639 return SWIG_Py_Void();
49640 }
49641
49642 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49643 return SWIG_Python_InitShadowInstance(args);
49644 }
49645
49646 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49647 PyObject *resultobj = 0;
49648 int arg1 = (int) 1 ;
49649 int arg2 = (int) 0 ;
49650 int arg3 = (int) 0 ;
49651 int arg4 = (int) 0 ;
49652 wxFlexGridSizer *result = 0 ;
49653 int val1 ;
49654 int ecode1 = 0 ;
49655 int val2 ;
49656 int ecode2 = 0 ;
49657 int val3 ;
49658 int ecode3 = 0 ;
49659 int val4 ;
49660 int ecode4 = 0 ;
49661 PyObject * obj0 = 0 ;
49662 PyObject * obj1 = 0 ;
49663 PyObject * obj2 = 0 ;
49664 PyObject * obj3 = 0 ;
49665 char * kwnames[] = {
49666 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49667 };
49668
49669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49670 if (obj0) {
49671 ecode1 = SWIG_AsVal_int(obj0, &val1);
49672 if (!SWIG_IsOK(ecode1)) {
49673 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49674 }
49675 arg1 = static_cast< int >(val1);
49676 }
49677 if (obj1) {
49678 ecode2 = SWIG_AsVal_int(obj1, &val2);
49679 if (!SWIG_IsOK(ecode2)) {
49680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49681 }
49682 arg2 = static_cast< int >(val2);
49683 }
49684 if (obj2) {
49685 ecode3 = SWIG_AsVal_int(obj2, &val3);
49686 if (!SWIG_IsOK(ecode3)) {
49687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49688 }
49689 arg3 = static_cast< int >(val3);
49690 }
49691 if (obj3) {
49692 ecode4 = SWIG_AsVal_int(obj3, &val4);
49693 if (!SWIG_IsOK(ecode4)) {
49694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49695 }
49696 arg4 = static_cast< int >(val4);
49697 }
49698 {
49699 PyThreadState* __tstate = wxPyBeginAllowThreads();
49700 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49701 wxPyEndAllowThreads(__tstate);
49702 if (PyErr_Occurred()) SWIG_fail;
49703 }
49704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49712 PyObject *resultobj = 0;
49713 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49714 size_t arg2 ;
49715 int arg3 = (int) 0 ;
49716 void *argp1 = 0 ;
49717 int res1 = 0 ;
49718 size_t val2 ;
49719 int ecode2 = 0 ;
49720 int val3 ;
49721 int ecode3 = 0 ;
49722 PyObject * obj0 = 0 ;
49723 PyObject * obj1 = 0 ;
49724 PyObject * obj2 = 0 ;
49725 char * kwnames[] = {
49726 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49727 };
49728
49729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49731 if (!SWIG_IsOK(res1)) {
49732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49733 }
49734 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49736 if (!SWIG_IsOK(ecode2)) {
49737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49738 }
49739 arg2 = static_cast< size_t >(val2);
49740 if (obj2) {
49741 ecode3 = SWIG_AsVal_int(obj2, &val3);
49742 if (!SWIG_IsOK(ecode3)) {
49743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49744 }
49745 arg3 = static_cast< int >(val3);
49746 }
49747 {
49748 PyThreadState* __tstate = wxPyBeginAllowThreads();
49749 (arg1)->AddGrowableRow(arg2,arg3);
49750 wxPyEndAllowThreads(__tstate);
49751 if (PyErr_Occurred()) SWIG_fail;
49752 }
49753 resultobj = SWIG_Py_Void();
49754 return resultobj;
49755 fail:
49756 return NULL;
49757 }
49758
49759
49760 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49761 PyObject *resultobj = 0;
49762 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49763 size_t arg2 ;
49764 void *argp1 = 0 ;
49765 int res1 = 0 ;
49766 size_t val2 ;
49767 int ecode2 = 0 ;
49768 PyObject * obj0 = 0 ;
49769 PyObject * obj1 = 0 ;
49770 char * kwnames[] = {
49771 (char *) "self",(char *) "idx", NULL
49772 };
49773
49774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49776 if (!SWIG_IsOK(res1)) {
49777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49778 }
49779 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49780 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49781 if (!SWIG_IsOK(ecode2)) {
49782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49783 }
49784 arg2 = static_cast< size_t >(val2);
49785 {
49786 PyThreadState* __tstate = wxPyBeginAllowThreads();
49787 (arg1)->RemoveGrowableRow(arg2);
49788 wxPyEndAllowThreads(__tstate);
49789 if (PyErr_Occurred()) SWIG_fail;
49790 }
49791 resultobj = SWIG_Py_Void();
49792 return resultobj;
49793 fail:
49794 return NULL;
49795 }
49796
49797
49798 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49799 PyObject *resultobj = 0;
49800 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49801 size_t arg2 ;
49802 int arg3 = (int) 0 ;
49803 void *argp1 = 0 ;
49804 int res1 = 0 ;
49805 size_t val2 ;
49806 int ecode2 = 0 ;
49807 int val3 ;
49808 int ecode3 = 0 ;
49809 PyObject * obj0 = 0 ;
49810 PyObject * obj1 = 0 ;
49811 PyObject * obj2 = 0 ;
49812 char * kwnames[] = {
49813 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49814 };
49815
49816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49818 if (!SWIG_IsOK(res1)) {
49819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49820 }
49821 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49822 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49823 if (!SWIG_IsOK(ecode2)) {
49824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49825 }
49826 arg2 = static_cast< size_t >(val2);
49827 if (obj2) {
49828 ecode3 = SWIG_AsVal_int(obj2, &val3);
49829 if (!SWIG_IsOK(ecode3)) {
49830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49831 }
49832 arg3 = static_cast< int >(val3);
49833 }
49834 {
49835 PyThreadState* __tstate = wxPyBeginAllowThreads();
49836 (arg1)->AddGrowableCol(arg2,arg3);
49837 wxPyEndAllowThreads(__tstate);
49838 if (PyErr_Occurred()) SWIG_fail;
49839 }
49840 resultobj = SWIG_Py_Void();
49841 return resultobj;
49842 fail:
49843 return NULL;
49844 }
49845
49846
49847 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49848 PyObject *resultobj = 0;
49849 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49850 size_t arg2 ;
49851 void *argp1 = 0 ;
49852 int res1 = 0 ;
49853 size_t val2 ;
49854 int ecode2 = 0 ;
49855 PyObject * obj0 = 0 ;
49856 PyObject * obj1 = 0 ;
49857 char * kwnames[] = {
49858 (char *) "self",(char *) "idx", NULL
49859 };
49860
49861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49863 if (!SWIG_IsOK(res1)) {
49864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49865 }
49866 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49867 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49868 if (!SWIG_IsOK(ecode2)) {
49869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49870 }
49871 arg2 = static_cast< size_t >(val2);
49872 {
49873 PyThreadState* __tstate = wxPyBeginAllowThreads();
49874 (arg1)->RemoveGrowableCol(arg2);
49875 wxPyEndAllowThreads(__tstate);
49876 if (PyErr_Occurred()) SWIG_fail;
49877 }
49878 resultobj = SWIG_Py_Void();
49879 return resultobj;
49880 fail:
49881 return NULL;
49882 }
49883
49884
49885 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49886 PyObject *resultobj = 0;
49887 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49888 int arg2 ;
49889 void *argp1 = 0 ;
49890 int res1 = 0 ;
49891 int val2 ;
49892 int ecode2 = 0 ;
49893 PyObject * obj0 = 0 ;
49894 PyObject * obj1 = 0 ;
49895 char * kwnames[] = {
49896 (char *) "self",(char *) "direction", NULL
49897 };
49898
49899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49901 if (!SWIG_IsOK(res1)) {
49902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49903 }
49904 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49905 ecode2 = SWIG_AsVal_int(obj1, &val2);
49906 if (!SWIG_IsOK(ecode2)) {
49907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49908 }
49909 arg2 = static_cast< int >(val2);
49910 {
49911 PyThreadState* __tstate = wxPyBeginAllowThreads();
49912 (arg1)->SetFlexibleDirection(arg2);
49913 wxPyEndAllowThreads(__tstate);
49914 if (PyErr_Occurred()) SWIG_fail;
49915 }
49916 resultobj = SWIG_Py_Void();
49917 return resultobj;
49918 fail:
49919 return NULL;
49920 }
49921
49922
49923 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49924 PyObject *resultobj = 0;
49925 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49926 int result;
49927 void *argp1 = 0 ;
49928 int res1 = 0 ;
49929 PyObject *swig_obj[1] ;
49930
49931 if (!args) SWIG_fail;
49932 swig_obj[0] = args;
49933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49934 if (!SWIG_IsOK(res1)) {
49935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49936 }
49937 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49938 {
49939 PyThreadState* __tstate = wxPyBeginAllowThreads();
49940 result = (int)(arg1)->GetFlexibleDirection();
49941 wxPyEndAllowThreads(__tstate);
49942 if (PyErr_Occurred()) SWIG_fail;
49943 }
49944 resultobj = SWIG_From_int(static_cast< int >(result));
49945 return resultobj;
49946 fail:
49947 return NULL;
49948 }
49949
49950
49951 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49952 PyObject *resultobj = 0;
49953 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49954 wxFlexSizerGrowMode arg2 ;
49955 void *argp1 = 0 ;
49956 int res1 = 0 ;
49957 int val2 ;
49958 int ecode2 = 0 ;
49959 PyObject * obj0 = 0 ;
49960 PyObject * obj1 = 0 ;
49961 char * kwnames[] = {
49962 (char *) "self",(char *) "mode", NULL
49963 };
49964
49965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49967 if (!SWIG_IsOK(res1)) {
49968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49969 }
49970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49971 ecode2 = SWIG_AsVal_int(obj1, &val2);
49972 if (!SWIG_IsOK(ecode2)) {
49973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49974 }
49975 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49976 {
49977 PyThreadState* __tstate = wxPyBeginAllowThreads();
49978 (arg1)->SetNonFlexibleGrowMode(arg2);
49979 wxPyEndAllowThreads(__tstate);
49980 if (PyErr_Occurred()) SWIG_fail;
49981 }
49982 resultobj = SWIG_Py_Void();
49983 return resultobj;
49984 fail:
49985 return NULL;
49986 }
49987
49988
49989 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49990 PyObject *resultobj = 0;
49991 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49992 wxFlexSizerGrowMode result;
49993 void *argp1 = 0 ;
49994 int res1 = 0 ;
49995 PyObject *swig_obj[1] ;
49996
49997 if (!args) SWIG_fail;
49998 swig_obj[0] = args;
49999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50000 if (!SWIG_IsOK(res1)) {
50001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
50002 }
50003 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50004 {
50005 PyThreadState* __tstate = wxPyBeginAllowThreads();
50006 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
50007 wxPyEndAllowThreads(__tstate);
50008 if (PyErr_Occurred()) SWIG_fail;
50009 }
50010 resultobj = SWIG_From_int(static_cast< int >(result));
50011 return resultobj;
50012 fail:
50013 return NULL;
50014 }
50015
50016
50017 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50018 PyObject *resultobj = 0;
50019 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50020 wxArrayInt *result = 0 ;
50021 void *argp1 = 0 ;
50022 int res1 = 0 ;
50023 PyObject *swig_obj[1] ;
50024
50025 if (!args) SWIG_fail;
50026 swig_obj[0] = args;
50027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50028 if (!SWIG_IsOK(res1)) {
50029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50030 }
50031 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50032 {
50033 PyThreadState* __tstate = wxPyBeginAllowThreads();
50034 {
50035 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50036 result = (wxArrayInt *) &_result_ref;
50037 }
50038 wxPyEndAllowThreads(__tstate);
50039 if (PyErr_Occurred()) SWIG_fail;
50040 }
50041 {
50042 resultobj = wxArrayInt2PyList_helper(*result);
50043 }
50044 return resultobj;
50045 fail:
50046 return NULL;
50047 }
50048
50049
50050 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50051 PyObject *resultobj = 0;
50052 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50053 wxArrayInt *result = 0 ;
50054 void *argp1 = 0 ;
50055 int res1 = 0 ;
50056 PyObject *swig_obj[1] ;
50057
50058 if (!args) SWIG_fail;
50059 swig_obj[0] = args;
50060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50061 if (!SWIG_IsOK(res1)) {
50062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50063 }
50064 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50065 {
50066 PyThreadState* __tstate = wxPyBeginAllowThreads();
50067 {
50068 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50069 result = (wxArrayInt *) &_result_ref;
50070 }
50071 wxPyEndAllowThreads(__tstate);
50072 if (PyErr_Occurred()) SWIG_fail;
50073 }
50074 {
50075 resultobj = wxArrayInt2PyList_helper(*result);
50076 }
50077 return resultobj;
50078 fail:
50079 return NULL;
50080 }
50081
50082
50083 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50084 PyObject *obj;
50085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50086 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50087 return SWIG_Py_Void();
50088 }
50089
50090 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50091 return SWIG_Python_InitShadowInstance(args);
50092 }
50093
50094 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50095 PyObject *resultobj = 0;
50096 wxStdDialogButtonSizer *result = 0 ;
50097
50098 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50099 {
50100 PyThreadState* __tstate = wxPyBeginAllowThreads();
50101 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50102 wxPyEndAllowThreads(__tstate);
50103 if (PyErr_Occurred()) SWIG_fail;
50104 }
50105 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50106 return resultobj;
50107 fail:
50108 return NULL;
50109 }
50110
50111
50112 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50113 PyObject *resultobj = 0;
50114 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50115 wxButton *arg2 = (wxButton *) 0 ;
50116 void *argp1 = 0 ;
50117 int res1 = 0 ;
50118 void *argp2 = 0 ;
50119 int res2 = 0 ;
50120 PyObject * obj0 = 0 ;
50121 PyObject * obj1 = 0 ;
50122 char * kwnames[] = {
50123 (char *) "self",(char *) "button", NULL
50124 };
50125
50126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50128 if (!SWIG_IsOK(res1)) {
50129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50130 }
50131 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50133 if (!SWIG_IsOK(res2)) {
50134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50135 }
50136 arg2 = reinterpret_cast< wxButton * >(argp2);
50137 {
50138 PyThreadState* __tstate = wxPyBeginAllowThreads();
50139 (arg1)->AddButton(arg2);
50140 wxPyEndAllowThreads(__tstate);
50141 if (PyErr_Occurred()) SWIG_fail;
50142 }
50143 resultobj = SWIG_Py_Void();
50144 return resultobj;
50145 fail:
50146 return NULL;
50147 }
50148
50149
50150 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50151 PyObject *resultobj = 0;
50152 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50153 void *argp1 = 0 ;
50154 int res1 = 0 ;
50155 PyObject *swig_obj[1] ;
50156
50157 if (!args) SWIG_fail;
50158 swig_obj[0] = args;
50159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50160 if (!SWIG_IsOK(res1)) {
50161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50162 }
50163 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50164 {
50165 PyThreadState* __tstate = wxPyBeginAllowThreads();
50166 (arg1)->Realize();
50167 wxPyEndAllowThreads(__tstate);
50168 if (PyErr_Occurred()) SWIG_fail;
50169 }
50170 resultobj = SWIG_Py_Void();
50171 return resultobj;
50172 fail:
50173 return NULL;
50174 }
50175
50176
50177 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50178 PyObject *resultobj = 0;
50179 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50180 wxButton *arg2 = (wxButton *) 0 ;
50181 void *argp1 = 0 ;
50182 int res1 = 0 ;
50183 void *argp2 = 0 ;
50184 int res2 = 0 ;
50185 PyObject * obj0 = 0 ;
50186 PyObject * obj1 = 0 ;
50187 char * kwnames[] = {
50188 (char *) "self",(char *) "button", NULL
50189 };
50190
50191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50193 if (!SWIG_IsOK(res1)) {
50194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50195 }
50196 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50197 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50198 if (!SWIG_IsOK(res2)) {
50199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50200 }
50201 arg2 = reinterpret_cast< wxButton * >(argp2);
50202 {
50203 PyThreadState* __tstate = wxPyBeginAllowThreads();
50204 (arg1)->SetAffirmativeButton(arg2);
50205 wxPyEndAllowThreads(__tstate);
50206 if (PyErr_Occurred()) SWIG_fail;
50207 }
50208 resultobj = SWIG_Py_Void();
50209 return resultobj;
50210 fail:
50211 return NULL;
50212 }
50213
50214
50215 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50216 PyObject *resultobj = 0;
50217 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50218 wxButton *arg2 = (wxButton *) 0 ;
50219 void *argp1 = 0 ;
50220 int res1 = 0 ;
50221 void *argp2 = 0 ;
50222 int res2 = 0 ;
50223 PyObject * obj0 = 0 ;
50224 PyObject * obj1 = 0 ;
50225 char * kwnames[] = {
50226 (char *) "self",(char *) "button", NULL
50227 };
50228
50229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50231 if (!SWIG_IsOK(res1)) {
50232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50233 }
50234 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50236 if (!SWIG_IsOK(res2)) {
50237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50238 }
50239 arg2 = reinterpret_cast< wxButton * >(argp2);
50240 {
50241 PyThreadState* __tstate = wxPyBeginAllowThreads();
50242 (arg1)->SetNegativeButton(arg2);
50243 wxPyEndAllowThreads(__tstate);
50244 if (PyErr_Occurred()) SWIG_fail;
50245 }
50246 resultobj = SWIG_Py_Void();
50247 return resultobj;
50248 fail:
50249 return NULL;
50250 }
50251
50252
50253 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50254 PyObject *resultobj = 0;
50255 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50256 wxButton *arg2 = (wxButton *) 0 ;
50257 void *argp1 = 0 ;
50258 int res1 = 0 ;
50259 void *argp2 = 0 ;
50260 int res2 = 0 ;
50261 PyObject * obj0 = 0 ;
50262 PyObject * obj1 = 0 ;
50263 char * kwnames[] = {
50264 (char *) "self",(char *) "button", NULL
50265 };
50266
50267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50269 if (!SWIG_IsOK(res1)) {
50270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50271 }
50272 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50274 if (!SWIG_IsOK(res2)) {
50275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50276 }
50277 arg2 = reinterpret_cast< wxButton * >(argp2);
50278 {
50279 PyThreadState* __tstate = wxPyBeginAllowThreads();
50280 (arg1)->SetCancelButton(arg2);
50281 wxPyEndAllowThreads(__tstate);
50282 if (PyErr_Occurred()) SWIG_fail;
50283 }
50284 resultobj = SWIG_Py_Void();
50285 return resultobj;
50286 fail:
50287 return NULL;
50288 }
50289
50290
50291 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50292 PyObject *resultobj = 0;
50293 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50294 wxButton *result = 0 ;
50295 void *argp1 = 0 ;
50296 int res1 = 0 ;
50297 PyObject *swig_obj[1] ;
50298
50299 if (!args) SWIG_fail;
50300 swig_obj[0] = args;
50301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50302 if (!SWIG_IsOK(res1)) {
50303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50304 }
50305 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50306 {
50307 PyThreadState* __tstate = wxPyBeginAllowThreads();
50308 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50309 wxPyEndAllowThreads(__tstate);
50310 if (PyErr_Occurred()) SWIG_fail;
50311 }
50312 {
50313 resultobj = wxPyMake_wxObject(result, (bool)0);
50314 }
50315 return resultobj;
50316 fail:
50317 return NULL;
50318 }
50319
50320
50321 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50322 PyObject *resultobj = 0;
50323 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50324 wxButton *result = 0 ;
50325 void *argp1 = 0 ;
50326 int res1 = 0 ;
50327 PyObject *swig_obj[1] ;
50328
50329 if (!args) SWIG_fail;
50330 swig_obj[0] = args;
50331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50332 if (!SWIG_IsOK(res1)) {
50333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50334 }
50335 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50336 {
50337 PyThreadState* __tstate = wxPyBeginAllowThreads();
50338 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50339 wxPyEndAllowThreads(__tstate);
50340 if (PyErr_Occurred()) SWIG_fail;
50341 }
50342 {
50343 resultobj = wxPyMake_wxObject(result, (bool)0);
50344 }
50345 return resultobj;
50346 fail:
50347 return NULL;
50348 }
50349
50350
50351 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50352 PyObject *resultobj = 0;
50353 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50354 wxButton *result = 0 ;
50355 void *argp1 = 0 ;
50356 int res1 = 0 ;
50357 PyObject *swig_obj[1] ;
50358
50359 if (!args) SWIG_fail;
50360 swig_obj[0] = args;
50361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50362 if (!SWIG_IsOK(res1)) {
50363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50364 }
50365 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50366 {
50367 PyThreadState* __tstate = wxPyBeginAllowThreads();
50368 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50369 wxPyEndAllowThreads(__tstate);
50370 if (PyErr_Occurred()) SWIG_fail;
50371 }
50372 {
50373 resultobj = wxPyMake_wxObject(result, (bool)0);
50374 }
50375 return resultobj;
50376 fail:
50377 return NULL;
50378 }
50379
50380
50381 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50382 PyObject *resultobj = 0;
50383 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50384 wxButton *result = 0 ;
50385 void *argp1 = 0 ;
50386 int res1 = 0 ;
50387 PyObject *swig_obj[1] ;
50388
50389 if (!args) SWIG_fail;
50390 swig_obj[0] = args;
50391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50394 }
50395 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50396 {
50397 PyThreadState* __tstate = wxPyBeginAllowThreads();
50398 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50399 wxPyEndAllowThreads(__tstate);
50400 if (PyErr_Occurred()) SWIG_fail;
50401 }
50402 {
50403 resultobj = wxPyMake_wxObject(result, (bool)0);
50404 }
50405 return resultobj;
50406 fail:
50407 return NULL;
50408 }
50409
50410
50411 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50412 PyObject *resultobj = 0;
50413 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50414 wxButton *result = 0 ;
50415 void *argp1 = 0 ;
50416 int res1 = 0 ;
50417 PyObject *swig_obj[1] ;
50418
50419 if (!args) SWIG_fail;
50420 swig_obj[0] = args;
50421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50422 if (!SWIG_IsOK(res1)) {
50423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50424 }
50425 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50426 {
50427 PyThreadState* __tstate = wxPyBeginAllowThreads();
50428 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50429 wxPyEndAllowThreads(__tstate);
50430 if (PyErr_Occurred()) SWIG_fail;
50431 }
50432 {
50433 resultobj = wxPyMake_wxObject(result, (bool)0);
50434 }
50435 return resultobj;
50436 fail:
50437 return NULL;
50438 }
50439
50440
50441 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50442 PyObject *obj;
50443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50444 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50445 return SWIG_Py_Void();
50446 }
50447
50448 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50449 return SWIG_Python_InitShadowInstance(args);
50450 }
50451
50452 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50453 PyObject *resultobj = 0;
50454 int arg1 = (int) 0 ;
50455 int arg2 = (int) 0 ;
50456 wxGBPosition *result = 0 ;
50457 int val1 ;
50458 int ecode1 = 0 ;
50459 int val2 ;
50460 int ecode2 = 0 ;
50461 PyObject * obj0 = 0 ;
50462 PyObject * obj1 = 0 ;
50463 char * kwnames[] = {
50464 (char *) "row",(char *) "col", NULL
50465 };
50466
50467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50468 if (obj0) {
50469 ecode1 = SWIG_AsVal_int(obj0, &val1);
50470 if (!SWIG_IsOK(ecode1)) {
50471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50472 }
50473 arg1 = static_cast< int >(val1);
50474 }
50475 if (obj1) {
50476 ecode2 = SWIG_AsVal_int(obj1, &val2);
50477 if (!SWIG_IsOK(ecode2)) {
50478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50479 }
50480 arg2 = static_cast< int >(val2);
50481 }
50482 {
50483 PyThreadState* __tstate = wxPyBeginAllowThreads();
50484 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50485 wxPyEndAllowThreads(__tstate);
50486 if (PyErr_Occurred()) SWIG_fail;
50487 }
50488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50489 return resultobj;
50490 fail:
50491 return NULL;
50492 }
50493
50494
50495 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50496 PyObject *resultobj = 0;
50497 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50498 void *argp1 = 0 ;
50499 int res1 = 0 ;
50500 PyObject *swig_obj[1] ;
50501
50502 if (!args) SWIG_fail;
50503 swig_obj[0] = args;
50504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50505 if (!SWIG_IsOK(res1)) {
50506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50507 }
50508 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50509 {
50510 PyThreadState* __tstate = wxPyBeginAllowThreads();
50511 delete arg1;
50512
50513 wxPyEndAllowThreads(__tstate);
50514 if (PyErr_Occurred()) SWIG_fail;
50515 }
50516 resultobj = SWIG_Py_Void();
50517 return resultobj;
50518 fail:
50519 return NULL;
50520 }
50521
50522
50523 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50524 PyObject *resultobj = 0;
50525 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50526 int result;
50527 void *argp1 = 0 ;
50528 int res1 = 0 ;
50529 PyObject *swig_obj[1] ;
50530
50531 if (!args) SWIG_fail;
50532 swig_obj[0] = args;
50533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50534 if (!SWIG_IsOK(res1)) {
50535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50536 }
50537 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50538 {
50539 PyThreadState* __tstate = wxPyBeginAllowThreads();
50540 result = (int)((wxGBPosition const *)arg1)->GetRow();
50541 wxPyEndAllowThreads(__tstate);
50542 if (PyErr_Occurred()) SWIG_fail;
50543 }
50544 resultobj = SWIG_From_int(static_cast< int >(result));
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50552 PyObject *resultobj = 0;
50553 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50554 int result;
50555 void *argp1 = 0 ;
50556 int res1 = 0 ;
50557 PyObject *swig_obj[1] ;
50558
50559 if (!args) SWIG_fail;
50560 swig_obj[0] = args;
50561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50562 if (!SWIG_IsOK(res1)) {
50563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50564 }
50565 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50566 {
50567 PyThreadState* __tstate = wxPyBeginAllowThreads();
50568 result = (int)((wxGBPosition const *)arg1)->GetCol();
50569 wxPyEndAllowThreads(__tstate);
50570 if (PyErr_Occurred()) SWIG_fail;
50571 }
50572 resultobj = SWIG_From_int(static_cast< int >(result));
50573 return resultobj;
50574 fail:
50575 return NULL;
50576 }
50577
50578
50579 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50580 PyObject *resultobj = 0;
50581 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50582 int arg2 ;
50583 void *argp1 = 0 ;
50584 int res1 = 0 ;
50585 int val2 ;
50586 int ecode2 = 0 ;
50587 PyObject * obj0 = 0 ;
50588 PyObject * obj1 = 0 ;
50589 char * kwnames[] = {
50590 (char *) "self",(char *) "row", NULL
50591 };
50592
50593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50595 if (!SWIG_IsOK(res1)) {
50596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50597 }
50598 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50599 ecode2 = SWIG_AsVal_int(obj1, &val2);
50600 if (!SWIG_IsOK(ecode2)) {
50601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50602 }
50603 arg2 = static_cast< int >(val2);
50604 {
50605 PyThreadState* __tstate = wxPyBeginAllowThreads();
50606 (arg1)->SetRow(arg2);
50607 wxPyEndAllowThreads(__tstate);
50608 if (PyErr_Occurred()) SWIG_fail;
50609 }
50610 resultobj = SWIG_Py_Void();
50611 return resultobj;
50612 fail:
50613 return NULL;
50614 }
50615
50616
50617 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50618 PyObject *resultobj = 0;
50619 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50620 int arg2 ;
50621 void *argp1 = 0 ;
50622 int res1 = 0 ;
50623 int val2 ;
50624 int ecode2 = 0 ;
50625 PyObject * obj0 = 0 ;
50626 PyObject * obj1 = 0 ;
50627 char * kwnames[] = {
50628 (char *) "self",(char *) "col", NULL
50629 };
50630
50631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50633 if (!SWIG_IsOK(res1)) {
50634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50635 }
50636 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50637 ecode2 = SWIG_AsVal_int(obj1, &val2);
50638 if (!SWIG_IsOK(ecode2)) {
50639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50640 }
50641 arg2 = static_cast< int >(val2);
50642 {
50643 PyThreadState* __tstate = wxPyBeginAllowThreads();
50644 (arg1)->SetCol(arg2);
50645 wxPyEndAllowThreads(__tstate);
50646 if (PyErr_Occurred()) SWIG_fail;
50647 }
50648 resultobj = SWIG_Py_Void();
50649 return resultobj;
50650 fail:
50651 return NULL;
50652 }
50653
50654
50655 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50656 PyObject *resultobj = 0;
50657 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50658 PyObject *arg2 = (PyObject *) 0 ;
50659 bool result;
50660 void *argp1 = 0 ;
50661 int res1 = 0 ;
50662 PyObject * obj0 = 0 ;
50663 PyObject * obj1 = 0 ;
50664 char * kwnames[] = {
50665 (char *) "self",(char *) "other", NULL
50666 };
50667
50668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50670 if (!SWIG_IsOK(res1)) {
50671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50672 }
50673 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50674 arg2 = obj1;
50675 {
50676 result = (bool)wxGBPosition___eq__(arg1,arg2);
50677 if (PyErr_Occurred()) SWIG_fail;
50678 }
50679 {
50680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50681 }
50682 return resultobj;
50683 fail:
50684 return NULL;
50685 }
50686
50687
50688 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50689 PyObject *resultobj = 0;
50690 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50691 PyObject *arg2 = (PyObject *) 0 ;
50692 bool result;
50693 void *argp1 = 0 ;
50694 int res1 = 0 ;
50695 PyObject * obj0 = 0 ;
50696 PyObject * obj1 = 0 ;
50697 char * kwnames[] = {
50698 (char *) "self",(char *) "other", NULL
50699 };
50700
50701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50703 if (!SWIG_IsOK(res1)) {
50704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50705 }
50706 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50707 arg2 = obj1;
50708 {
50709 result = (bool)wxGBPosition___ne__(arg1,arg2);
50710 if (PyErr_Occurred()) SWIG_fail;
50711 }
50712 {
50713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50714 }
50715 return resultobj;
50716 fail:
50717 return NULL;
50718 }
50719
50720
50721 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50722 PyObject *resultobj = 0;
50723 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50724 int arg2 = (int) 0 ;
50725 int arg3 = (int) 0 ;
50726 void *argp1 = 0 ;
50727 int res1 = 0 ;
50728 int val2 ;
50729 int ecode2 = 0 ;
50730 int val3 ;
50731 int ecode3 = 0 ;
50732 PyObject * obj0 = 0 ;
50733 PyObject * obj1 = 0 ;
50734 PyObject * obj2 = 0 ;
50735 char * kwnames[] = {
50736 (char *) "self",(char *) "row",(char *) "col", NULL
50737 };
50738
50739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50741 if (!SWIG_IsOK(res1)) {
50742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50743 }
50744 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50745 if (obj1) {
50746 ecode2 = SWIG_AsVal_int(obj1, &val2);
50747 if (!SWIG_IsOK(ecode2)) {
50748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50749 }
50750 arg2 = static_cast< int >(val2);
50751 }
50752 if (obj2) {
50753 ecode3 = SWIG_AsVal_int(obj2, &val3);
50754 if (!SWIG_IsOK(ecode3)) {
50755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50756 }
50757 arg3 = static_cast< int >(val3);
50758 }
50759 {
50760 PyThreadState* __tstate = wxPyBeginAllowThreads();
50761 wxGBPosition_Set(arg1,arg2,arg3);
50762 wxPyEndAllowThreads(__tstate);
50763 if (PyErr_Occurred()) SWIG_fail;
50764 }
50765 resultobj = SWIG_Py_Void();
50766 return resultobj;
50767 fail:
50768 return NULL;
50769 }
50770
50771
50772 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50773 PyObject *resultobj = 0;
50774 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50775 PyObject *result = 0 ;
50776 void *argp1 = 0 ;
50777 int res1 = 0 ;
50778 PyObject *swig_obj[1] ;
50779
50780 if (!args) SWIG_fail;
50781 swig_obj[0] = args;
50782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50783 if (!SWIG_IsOK(res1)) {
50784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50785 }
50786 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50787 {
50788 PyThreadState* __tstate = wxPyBeginAllowThreads();
50789 result = (PyObject *)wxGBPosition_Get(arg1);
50790 wxPyEndAllowThreads(__tstate);
50791 if (PyErr_Occurred()) SWIG_fail;
50792 }
50793 resultobj = result;
50794 return resultobj;
50795 fail:
50796 return NULL;
50797 }
50798
50799
50800 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50801 PyObject *obj;
50802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50803 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50804 return SWIG_Py_Void();
50805 }
50806
50807 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50808 return SWIG_Python_InitShadowInstance(args);
50809 }
50810
50811 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50812 PyObject *resultobj = 0;
50813 int arg1 = (int) 1 ;
50814 int arg2 = (int) 1 ;
50815 wxGBSpan *result = 0 ;
50816 int val1 ;
50817 int ecode1 = 0 ;
50818 int val2 ;
50819 int ecode2 = 0 ;
50820 PyObject * obj0 = 0 ;
50821 PyObject * obj1 = 0 ;
50822 char * kwnames[] = {
50823 (char *) "rowspan",(char *) "colspan", NULL
50824 };
50825
50826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50827 if (obj0) {
50828 ecode1 = SWIG_AsVal_int(obj0, &val1);
50829 if (!SWIG_IsOK(ecode1)) {
50830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50831 }
50832 arg1 = static_cast< int >(val1);
50833 }
50834 if (obj1) {
50835 ecode2 = SWIG_AsVal_int(obj1, &val2);
50836 if (!SWIG_IsOK(ecode2)) {
50837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50838 }
50839 arg2 = static_cast< int >(val2);
50840 }
50841 {
50842 PyThreadState* __tstate = wxPyBeginAllowThreads();
50843 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50844 wxPyEndAllowThreads(__tstate);
50845 if (PyErr_Occurred()) SWIG_fail;
50846 }
50847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50848 return resultobj;
50849 fail:
50850 return NULL;
50851 }
50852
50853
50854 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50855 PyObject *resultobj = 0;
50856 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50857 void *argp1 = 0 ;
50858 int res1 = 0 ;
50859 PyObject *swig_obj[1] ;
50860
50861 if (!args) SWIG_fail;
50862 swig_obj[0] = args;
50863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50864 if (!SWIG_IsOK(res1)) {
50865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50866 }
50867 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50868 {
50869 PyThreadState* __tstate = wxPyBeginAllowThreads();
50870 delete arg1;
50871
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 resultobj = SWIG_Py_Void();
50876 return resultobj;
50877 fail:
50878 return NULL;
50879 }
50880
50881
50882 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50883 PyObject *resultobj = 0;
50884 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50885 int result;
50886 void *argp1 = 0 ;
50887 int res1 = 0 ;
50888 PyObject *swig_obj[1] ;
50889
50890 if (!args) SWIG_fail;
50891 swig_obj[0] = args;
50892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50893 if (!SWIG_IsOK(res1)) {
50894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50895 }
50896 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50897 {
50898 PyThreadState* __tstate = wxPyBeginAllowThreads();
50899 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50900 wxPyEndAllowThreads(__tstate);
50901 if (PyErr_Occurred()) SWIG_fail;
50902 }
50903 resultobj = SWIG_From_int(static_cast< int >(result));
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50911 PyObject *resultobj = 0;
50912 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50913 int result;
50914 void *argp1 = 0 ;
50915 int res1 = 0 ;
50916 PyObject *swig_obj[1] ;
50917
50918 if (!args) SWIG_fail;
50919 swig_obj[0] = args;
50920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50921 if (!SWIG_IsOK(res1)) {
50922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50923 }
50924 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50925 {
50926 PyThreadState* __tstate = wxPyBeginAllowThreads();
50927 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50928 wxPyEndAllowThreads(__tstate);
50929 if (PyErr_Occurred()) SWIG_fail;
50930 }
50931 resultobj = SWIG_From_int(static_cast< int >(result));
50932 return resultobj;
50933 fail:
50934 return NULL;
50935 }
50936
50937
50938 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50939 PyObject *resultobj = 0;
50940 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50941 int arg2 ;
50942 void *argp1 = 0 ;
50943 int res1 = 0 ;
50944 int val2 ;
50945 int ecode2 = 0 ;
50946 PyObject * obj0 = 0 ;
50947 PyObject * obj1 = 0 ;
50948 char * kwnames[] = {
50949 (char *) "self",(char *) "rowspan", NULL
50950 };
50951
50952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50954 if (!SWIG_IsOK(res1)) {
50955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50956 }
50957 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50958 ecode2 = SWIG_AsVal_int(obj1, &val2);
50959 if (!SWIG_IsOK(ecode2)) {
50960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50961 }
50962 arg2 = static_cast< int >(val2);
50963 {
50964 PyThreadState* __tstate = wxPyBeginAllowThreads();
50965 (arg1)->SetRowspan(arg2);
50966 wxPyEndAllowThreads(__tstate);
50967 if (PyErr_Occurred()) SWIG_fail;
50968 }
50969 resultobj = SWIG_Py_Void();
50970 return resultobj;
50971 fail:
50972 return NULL;
50973 }
50974
50975
50976 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50977 PyObject *resultobj = 0;
50978 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50979 int arg2 ;
50980 void *argp1 = 0 ;
50981 int res1 = 0 ;
50982 int val2 ;
50983 int ecode2 = 0 ;
50984 PyObject * obj0 = 0 ;
50985 PyObject * obj1 = 0 ;
50986 char * kwnames[] = {
50987 (char *) "self",(char *) "colspan", NULL
50988 };
50989
50990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50992 if (!SWIG_IsOK(res1)) {
50993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50994 }
50995 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50996 ecode2 = SWIG_AsVal_int(obj1, &val2);
50997 if (!SWIG_IsOK(ecode2)) {
50998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50999 }
51000 arg2 = static_cast< int >(val2);
51001 {
51002 PyThreadState* __tstate = wxPyBeginAllowThreads();
51003 (arg1)->SetColspan(arg2);
51004 wxPyEndAllowThreads(__tstate);
51005 if (PyErr_Occurred()) SWIG_fail;
51006 }
51007 resultobj = SWIG_Py_Void();
51008 return resultobj;
51009 fail:
51010 return NULL;
51011 }
51012
51013
51014 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51015 PyObject *resultobj = 0;
51016 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51017 PyObject *arg2 = (PyObject *) 0 ;
51018 bool result;
51019 void *argp1 = 0 ;
51020 int res1 = 0 ;
51021 PyObject * obj0 = 0 ;
51022 PyObject * obj1 = 0 ;
51023 char * kwnames[] = {
51024 (char *) "self",(char *) "other", NULL
51025 };
51026
51027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
51028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51029 if (!SWIG_IsOK(res1)) {
51030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51031 }
51032 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51033 arg2 = obj1;
51034 {
51035 result = (bool)wxGBSpan___eq__(arg1,arg2);
51036 if (PyErr_Occurred()) SWIG_fail;
51037 }
51038 {
51039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51040 }
51041 return resultobj;
51042 fail:
51043 return NULL;
51044 }
51045
51046
51047 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51048 PyObject *resultobj = 0;
51049 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51050 PyObject *arg2 = (PyObject *) 0 ;
51051 bool result;
51052 void *argp1 = 0 ;
51053 int res1 = 0 ;
51054 PyObject * obj0 = 0 ;
51055 PyObject * obj1 = 0 ;
51056 char * kwnames[] = {
51057 (char *) "self",(char *) "other", NULL
51058 };
51059
51060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51062 if (!SWIG_IsOK(res1)) {
51063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51064 }
51065 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51066 arg2 = obj1;
51067 {
51068 result = (bool)wxGBSpan___ne__(arg1,arg2);
51069 if (PyErr_Occurred()) SWIG_fail;
51070 }
51071 {
51072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51073 }
51074 return resultobj;
51075 fail:
51076 return NULL;
51077 }
51078
51079
51080 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51081 PyObject *resultobj = 0;
51082 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51083 int arg2 = (int) 1 ;
51084 int arg3 = (int) 1 ;
51085 void *argp1 = 0 ;
51086 int res1 = 0 ;
51087 int val2 ;
51088 int ecode2 = 0 ;
51089 int val3 ;
51090 int ecode3 = 0 ;
51091 PyObject * obj0 = 0 ;
51092 PyObject * obj1 = 0 ;
51093 PyObject * obj2 = 0 ;
51094 char * kwnames[] = {
51095 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51096 };
51097
51098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51100 if (!SWIG_IsOK(res1)) {
51101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51102 }
51103 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51104 if (obj1) {
51105 ecode2 = SWIG_AsVal_int(obj1, &val2);
51106 if (!SWIG_IsOK(ecode2)) {
51107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51108 }
51109 arg2 = static_cast< int >(val2);
51110 }
51111 if (obj2) {
51112 ecode3 = SWIG_AsVal_int(obj2, &val3);
51113 if (!SWIG_IsOK(ecode3)) {
51114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51115 }
51116 arg3 = static_cast< int >(val3);
51117 }
51118 {
51119 PyThreadState* __tstate = wxPyBeginAllowThreads();
51120 wxGBSpan_Set(arg1,arg2,arg3);
51121 wxPyEndAllowThreads(__tstate);
51122 if (PyErr_Occurred()) SWIG_fail;
51123 }
51124 resultobj = SWIG_Py_Void();
51125 return resultobj;
51126 fail:
51127 return NULL;
51128 }
51129
51130
51131 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51132 PyObject *resultobj = 0;
51133 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51134 PyObject *result = 0 ;
51135 void *argp1 = 0 ;
51136 int res1 = 0 ;
51137 PyObject *swig_obj[1] ;
51138
51139 if (!args) SWIG_fail;
51140 swig_obj[0] = args;
51141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51142 if (!SWIG_IsOK(res1)) {
51143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51144 }
51145 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51146 {
51147 PyThreadState* __tstate = wxPyBeginAllowThreads();
51148 result = (PyObject *)wxGBSpan_Get(arg1);
51149 wxPyEndAllowThreads(__tstate);
51150 if (PyErr_Occurred()) SWIG_fail;
51151 }
51152 resultobj = result;
51153 return resultobj;
51154 fail:
51155 return NULL;
51156 }
51157
51158
51159 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51160 PyObject *obj;
51161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51162 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51163 return SWIG_Py_Void();
51164 }
51165
51166 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51167 return SWIG_Python_InitShadowInstance(args);
51168 }
51169
51170 SWIGINTERN int DefaultSpan_set(PyObject *) {
51171 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51172 return 1;
51173 }
51174
51175
51176 SWIGINTERN PyObject *DefaultSpan_get(void) {
51177 PyObject *pyobj = 0;
51178
51179 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51180 return pyobj;
51181 }
51182
51183
51184 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51185 PyObject *resultobj = 0;
51186 wxGBSizerItem *result = 0 ;
51187
51188 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51189 {
51190 PyThreadState* __tstate = wxPyBeginAllowThreads();
51191 result = (wxGBSizerItem *)new wxGBSizerItem();
51192 wxPyEndAllowThreads(__tstate);
51193 if (PyErr_Occurred()) SWIG_fail;
51194 }
51195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51196 return resultobj;
51197 fail:
51198 return NULL;
51199 }
51200
51201
51202 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51203 PyObject *resultobj = 0;
51204 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51205 void *argp1 = 0 ;
51206 int res1 = 0 ;
51207 PyObject *swig_obj[1] ;
51208
51209 if (!args) SWIG_fail;
51210 swig_obj[0] = args;
51211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51212 if (!SWIG_IsOK(res1)) {
51213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51214 }
51215 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51216 {
51217 PyThreadState* __tstate = wxPyBeginAllowThreads();
51218 delete arg1;
51219
51220 wxPyEndAllowThreads(__tstate);
51221 if (PyErr_Occurred()) SWIG_fail;
51222 }
51223 resultobj = SWIG_Py_Void();
51224 return resultobj;
51225 fail:
51226 return NULL;
51227 }
51228
51229
51230 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51231 PyObject *resultobj = 0;
51232 wxWindow *arg1 = (wxWindow *) 0 ;
51233 wxGBPosition *arg2 = 0 ;
51234 wxGBSpan *arg3 = 0 ;
51235 int arg4 ;
51236 int arg5 ;
51237 PyObject *arg6 = (PyObject *) NULL ;
51238 wxGBSizerItem *result = 0 ;
51239 void *argp1 = 0 ;
51240 int res1 = 0 ;
51241 wxGBPosition temp2 ;
51242 wxGBSpan temp3 ;
51243 int val4 ;
51244 int ecode4 = 0 ;
51245 int val5 ;
51246 int ecode5 = 0 ;
51247 PyObject * obj0 = 0 ;
51248 PyObject * obj1 = 0 ;
51249 PyObject * obj2 = 0 ;
51250 PyObject * obj3 = 0 ;
51251 PyObject * obj4 = 0 ;
51252 PyObject * obj5 = 0 ;
51253 char * kwnames[] = {
51254 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51255 };
51256
51257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51259 if (!SWIG_IsOK(res1)) {
51260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51261 }
51262 arg1 = reinterpret_cast< wxWindow * >(argp1);
51263 {
51264 arg2 = &temp2;
51265 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51266 }
51267 {
51268 arg3 = &temp3;
51269 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51270 }
51271 ecode4 = SWIG_AsVal_int(obj3, &val4);
51272 if (!SWIG_IsOK(ecode4)) {
51273 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51274 }
51275 arg4 = static_cast< int >(val4);
51276 ecode5 = SWIG_AsVal_int(obj4, &val5);
51277 if (!SWIG_IsOK(ecode5)) {
51278 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51279 }
51280 arg5 = static_cast< int >(val5);
51281 if (obj5) {
51282 arg6 = obj5;
51283 }
51284 {
51285 PyThreadState* __tstate = wxPyBeginAllowThreads();
51286 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51287 wxPyEndAllowThreads(__tstate);
51288 if (PyErr_Occurred()) SWIG_fail;
51289 }
51290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51291 return resultobj;
51292 fail:
51293 return NULL;
51294 }
51295
51296
51297 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51298 PyObject *resultobj = 0;
51299 wxSizer *arg1 = (wxSizer *) 0 ;
51300 wxGBPosition *arg2 = 0 ;
51301 wxGBSpan *arg3 = 0 ;
51302 int arg4 ;
51303 int arg5 ;
51304 PyObject *arg6 = (PyObject *) NULL ;
51305 wxGBSizerItem *result = 0 ;
51306 int res1 = 0 ;
51307 wxGBPosition temp2 ;
51308 wxGBSpan temp3 ;
51309 int val4 ;
51310 int ecode4 = 0 ;
51311 int val5 ;
51312 int ecode5 = 0 ;
51313 PyObject * obj0 = 0 ;
51314 PyObject * obj1 = 0 ;
51315 PyObject * obj2 = 0 ;
51316 PyObject * obj3 = 0 ;
51317 PyObject * obj4 = 0 ;
51318 PyObject * obj5 = 0 ;
51319 char * kwnames[] = {
51320 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51321 };
51322
51323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51324 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51325 if (!SWIG_IsOK(res1)) {
51326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51327 }
51328 {
51329 arg2 = &temp2;
51330 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51331 }
51332 {
51333 arg3 = &temp3;
51334 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51335 }
51336 ecode4 = SWIG_AsVal_int(obj3, &val4);
51337 if (!SWIG_IsOK(ecode4)) {
51338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51339 }
51340 arg4 = static_cast< int >(val4);
51341 ecode5 = SWIG_AsVal_int(obj4, &val5);
51342 if (!SWIG_IsOK(ecode5)) {
51343 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51344 }
51345 arg5 = static_cast< int >(val5);
51346 if (obj5) {
51347 arg6 = obj5;
51348 }
51349 {
51350 PyThreadState* __tstate = wxPyBeginAllowThreads();
51351 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51352 wxPyEndAllowThreads(__tstate);
51353 if (PyErr_Occurred()) SWIG_fail;
51354 }
51355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51356 return resultobj;
51357 fail:
51358 return NULL;
51359 }
51360
51361
51362 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51363 PyObject *resultobj = 0;
51364 int arg1 ;
51365 int arg2 ;
51366 wxGBPosition *arg3 = 0 ;
51367 wxGBSpan *arg4 = 0 ;
51368 int arg5 ;
51369 int arg6 ;
51370 PyObject *arg7 = (PyObject *) NULL ;
51371 wxGBSizerItem *result = 0 ;
51372 int val1 ;
51373 int ecode1 = 0 ;
51374 int val2 ;
51375 int ecode2 = 0 ;
51376 wxGBPosition temp3 ;
51377 wxGBSpan temp4 ;
51378 int val5 ;
51379 int ecode5 = 0 ;
51380 int val6 ;
51381 int ecode6 = 0 ;
51382 PyObject * obj0 = 0 ;
51383 PyObject * obj1 = 0 ;
51384 PyObject * obj2 = 0 ;
51385 PyObject * obj3 = 0 ;
51386 PyObject * obj4 = 0 ;
51387 PyObject * obj5 = 0 ;
51388 PyObject * obj6 = 0 ;
51389 char * kwnames[] = {
51390 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51391 };
51392
51393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51394 ecode1 = SWIG_AsVal_int(obj0, &val1);
51395 if (!SWIG_IsOK(ecode1)) {
51396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51397 }
51398 arg1 = static_cast< int >(val1);
51399 ecode2 = SWIG_AsVal_int(obj1, &val2);
51400 if (!SWIG_IsOK(ecode2)) {
51401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51402 }
51403 arg2 = static_cast< int >(val2);
51404 {
51405 arg3 = &temp3;
51406 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51407 }
51408 {
51409 arg4 = &temp4;
51410 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51411 }
51412 ecode5 = SWIG_AsVal_int(obj4, &val5);
51413 if (!SWIG_IsOK(ecode5)) {
51414 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51415 }
51416 arg5 = static_cast< int >(val5);
51417 ecode6 = SWIG_AsVal_int(obj5, &val6);
51418 if (!SWIG_IsOK(ecode6)) {
51419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51420 }
51421 arg6 = static_cast< int >(val6);
51422 if (obj6) {
51423 arg7 = obj6;
51424 }
51425 {
51426 PyThreadState* __tstate = wxPyBeginAllowThreads();
51427 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51428 wxPyEndAllowThreads(__tstate);
51429 if (PyErr_Occurred()) SWIG_fail;
51430 }
51431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51432 return resultobj;
51433 fail:
51434 return NULL;
51435 }
51436
51437
51438 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51439 PyObject *resultobj = 0;
51440 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51441 wxGBPosition result;
51442 void *argp1 = 0 ;
51443 int res1 = 0 ;
51444 PyObject *swig_obj[1] ;
51445
51446 if (!args) SWIG_fail;
51447 swig_obj[0] = args;
51448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51449 if (!SWIG_IsOK(res1)) {
51450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51451 }
51452 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51453 {
51454 PyThreadState* __tstate = wxPyBeginAllowThreads();
51455 result = ((wxGBSizerItem const *)arg1)->GetPos();
51456 wxPyEndAllowThreads(__tstate);
51457 if (PyErr_Occurred()) SWIG_fail;
51458 }
51459 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51460 return resultobj;
51461 fail:
51462 return NULL;
51463 }
51464
51465
51466 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51467 PyObject *resultobj = 0;
51468 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51469 wxGBSpan result;
51470 void *argp1 = 0 ;
51471 int res1 = 0 ;
51472 PyObject *swig_obj[1] ;
51473
51474 if (!args) SWIG_fail;
51475 swig_obj[0] = args;
51476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51477 if (!SWIG_IsOK(res1)) {
51478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51479 }
51480 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51481 {
51482 PyThreadState* __tstate = wxPyBeginAllowThreads();
51483 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51484 wxPyEndAllowThreads(__tstate);
51485 if (PyErr_Occurred()) SWIG_fail;
51486 }
51487 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51488 return resultobj;
51489 fail:
51490 return NULL;
51491 }
51492
51493
51494 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51495 PyObject *resultobj = 0;
51496 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51497 wxGBPosition *arg2 = 0 ;
51498 bool result;
51499 void *argp1 = 0 ;
51500 int res1 = 0 ;
51501 wxGBPosition temp2 ;
51502 PyObject * obj0 = 0 ;
51503 PyObject * obj1 = 0 ;
51504 char * kwnames[] = {
51505 (char *) "self",(char *) "pos", NULL
51506 };
51507
51508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51510 if (!SWIG_IsOK(res1)) {
51511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51512 }
51513 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51514 {
51515 arg2 = &temp2;
51516 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51517 }
51518 {
51519 PyThreadState* __tstate = wxPyBeginAllowThreads();
51520 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51521 wxPyEndAllowThreads(__tstate);
51522 if (PyErr_Occurred()) SWIG_fail;
51523 }
51524 {
51525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51526 }
51527 return resultobj;
51528 fail:
51529 return NULL;
51530 }
51531
51532
51533 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51534 PyObject *resultobj = 0;
51535 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51536 wxGBSpan *arg2 = 0 ;
51537 bool result;
51538 void *argp1 = 0 ;
51539 int res1 = 0 ;
51540 wxGBSpan temp2 ;
51541 PyObject * obj0 = 0 ;
51542 PyObject * obj1 = 0 ;
51543 char * kwnames[] = {
51544 (char *) "self",(char *) "span", NULL
51545 };
51546
51547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51549 if (!SWIG_IsOK(res1)) {
51550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51551 }
51552 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51553 {
51554 arg2 = &temp2;
51555 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51556 }
51557 {
51558 PyThreadState* __tstate = wxPyBeginAllowThreads();
51559 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51560 wxPyEndAllowThreads(__tstate);
51561 if (PyErr_Occurred()) SWIG_fail;
51562 }
51563 {
51564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51565 }
51566 return resultobj;
51567 fail:
51568 return NULL;
51569 }
51570
51571
51572 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51573 PyObject *resultobj = 0;
51574 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51575 wxGBSizerItem *arg2 = 0 ;
51576 bool result;
51577 void *argp1 = 0 ;
51578 int res1 = 0 ;
51579 void *argp2 = 0 ;
51580 int res2 = 0 ;
51581 PyObject * obj0 = 0 ;
51582 PyObject * obj1 = 0 ;
51583 char * kwnames[] = {
51584 (char *) "self",(char *) "other", NULL
51585 };
51586
51587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51589 if (!SWIG_IsOK(res1)) {
51590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51591 }
51592 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51594 if (!SWIG_IsOK(res2)) {
51595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51596 }
51597 if (!argp2) {
51598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51599 }
51600 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51601 {
51602 PyThreadState* __tstate = wxPyBeginAllowThreads();
51603 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51604 wxPyEndAllowThreads(__tstate);
51605 if (PyErr_Occurred()) SWIG_fail;
51606 }
51607 {
51608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51609 }
51610 return resultobj;
51611 fail:
51612 return NULL;
51613 }
51614
51615
51616 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51617 PyObject *resultobj = 0;
51618 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51619 wxGBPosition *arg2 = 0 ;
51620 wxGBSpan *arg3 = 0 ;
51621 bool result;
51622 void *argp1 = 0 ;
51623 int res1 = 0 ;
51624 wxGBPosition temp2 ;
51625 wxGBSpan temp3 ;
51626 PyObject * obj0 = 0 ;
51627 PyObject * obj1 = 0 ;
51628 PyObject * obj2 = 0 ;
51629 char * kwnames[] = {
51630 (char *) "self",(char *) "pos",(char *) "span", NULL
51631 };
51632
51633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51635 if (!SWIG_IsOK(res1)) {
51636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51637 }
51638 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51639 {
51640 arg2 = &temp2;
51641 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51642 }
51643 {
51644 arg3 = &temp3;
51645 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51646 }
51647 {
51648 PyThreadState* __tstate = wxPyBeginAllowThreads();
51649 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51650 wxPyEndAllowThreads(__tstate);
51651 if (PyErr_Occurred()) SWIG_fail;
51652 }
51653 {
51654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51655 }
51656 return resultobj;
51657 fail:
51658 return NULL;
51659 }
51660
51661
51662 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51663 PyObject *resultobj = 0;
51664 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51665 wxGBPosition result;
51666 void *argp1 = 0 ;
51667 int res1 = 0 ;
51668 PyObject *swig_obj[1] ;
51669
51670 if (!args) SWIG_fail;
51671 swig_obj[0] = args;
51672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51673 if (!SWIG_IsOK(res1)) {
51674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51675 }
51676 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51677 {
51678 PyThreadState* __tstate = wxPyBeginAllowThreads();
51679 result = wxGBSizerItem_GetEndPos(arg1);
51680 wxPyEndAllowThreads(__tstate);
51681 if (PyErr_Occurred()) SWIG_fail;
51682 }
51683 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51684 return resultobj;
51685 fail:
51686 return NULL;
51687 }
51688
51689
51690 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51691 PyObject *resultobj = 0;
51692 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51693 wxGridBagSizer *result = 0 ;
51694 void *argp1 = 0 ;
51695 int res1 = 0 ;
51696 PyObject *swig_obj[1] ;
51697
51698 if (!args) SWIG_fail;
51699 swig_obj[0] = args;
51700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51701 if (!SWIG_IsOK(res1)) {
51702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51703 }
51704 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51705 {
51706 PyThreadState* __tstate = wxPyBeginAllowThreads();
51707 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51708 wxPyEndAllowThreads(__tstate);
51709 if (PyErr_Occurred()) SWIG_fail;
51710 }
51711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51712 return resultobj;
51713 fail:
51714 return NULL;
51715 }
51716
51717
51718 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51719 PyObject *resultobj = 0;
51720 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51721 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51722 void *argp1 = 0 ;
51723 int res1 = 0 ;
51724 void *argp2 = 0 ;
51725 int res2 = 0 ;
51726 PyObject * obj0 = 0 ;
51727 PyObject * obj1 = 0 ;
51728 char * kwnames[] = {
51729 (char *) "self",(char *) "sizer", NULL
51730 };
51731
51732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51734 if (!SWIG_IsOK(res1)) {
51735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51736 }
51737 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51739 if (!SWIG_IsOK(res2)) {
51740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51741 }
51742 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51743 {
51744 PyThreadState* __tstate = wxPyBeginAllowThreads();
51745 (arg1)->SetGBSizer(arg2);
51746 wxPyEndAllowThreads(__tstate);
51747 if (PyErr_Occurred()) SWIG_fail;
51748 }
51749 resultobj = SWIG_Py_Void();
51750 return resultobj;
51751 fail:
51752 return NULL;
51753 }
51754
51755
51756 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51757 PyObject *obj;
51758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51759 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51760 return SWIG_Py_Void();
51761 }
51762
51763 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51764 return SWIG_Python_InitShadowInstance(args);
51765 }
51766
51767 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51768 PyObject *resultobj = 0;
51769 int arg1 = (int) 0 ;
51770 int arg2 = (int) 0 ;
51771 wxGridBagSizer *result = 0 ;
51772 int val1 ;
51773 int ecode1 = 0 ;
51774 int val2 ;
51775 int ecode2 = 0 ;
51776 PyObject * obj0 = 0 ;
51777 PyObject * obj1 = 0 ;
51778 char * kwnames[] = {
51779 (char *) "vgap",(char *) "hgap", NULL
51780 };
51781
51782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51783 if (obj0) {
51784 ecode1 = SWIG_AsVal_int(obj0, &val1);
51785 if (!SWIG_IsOK(ecode1)) {
51786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51787 }
51788 arg1 = static_cast< int >(val1);
51789 }
51790 if (obj1) {
51791 ecode2 = SWIG_AsVal_int(obj1, &val2);
51792 if (!SWIG_IsOK(ecode2)) {
51793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51794 }
51795 arg2 = static_cast< int >(val2);
51796 }
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51804 return resultobj;
51805 fail:
51806 return NULL;
51807 }
51808
51809
51810 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51811 PyObject *resultobj = 0;
51812 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51813 PyObject *arg2 = (PyObject *) 0 ;
51814 wxGBPosition *arg3 = 0 ;
51815 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51816 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51817 int arg5 = (int) 0 ;
51818 int arg6 = (int) 0 ;
51819 PyObject *arg7 = (PyObject *) NULL ;
51820 wxGBSizerItem *result = 0 ;
51821 void *argp1 = 0 ;
51822 int res1 = 0 ;
51823 wxGBPosition temp3 ;
51824 wxGBSpan temp4 ;
51825 int val5 ;
51826 int ecode5 = 0 ;
51827 int val6 ;
51828 int ecode6 = 0 ;
51829 PyObject * obj0 = 0 ;
51830 PyObject * obj1 = 0 ;
51831 PyObject * obj2 = 0 ;
51832 PyObject * obj3 = 0 ;
51833 PyObject * obj4 = 0 ;
51834 PyObject * obj5 = 0 ;
51835 PyObject * obj6 = 0 ;
51836 char * kwnames[] = {
51837 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51838 };
51839
51840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51842 if (!SWIG_IsOK(res1)) {
51843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51844 }
51845 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51846 arg2 = obj1;
51847 {
51848 arg3 = &temp3;
51849 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51850 }
51851 if (obj3) {
51852 {
51853 arg4 = &temp4;
51854 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51855 }
51856 }
51857 if (obj4) {
51858 ecode5 = SWIG_AsVal_int(obj4, &val5);
51859 if (!SWIG_IsOK(ecode5)) {
51860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51861 }
51862 arg5 = static_cast< int >(val5);
51863 }
51864 if (obj5) {
51865 ecode6 = SWIG_AsVal_int(obj5, &val6);
51866 if (!SWIG_IsOK(ecode6)) {
51867 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51868 }
51869 arg6 = static_cast< int >(val6);
51870 }
51871 if (obj6) {
51872 arg7 = obj6;
51873 }
51874 {
51875 PyThreadState* __tstate = wxPyBeginAllowThreads();
51876 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51877 wxPyEndAllowThreads(__tstate);
51878 if (PyErr_Occurred()) SWIG_fail;
51879 }
51880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51881 return resultobj;
51882 fail:
51883 return NULL;
51884 }
51885
51886
51887 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51888 PyObject *resultobj = 0;
51889 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51890 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51891 wxGBSizerItem *result = 0 ;
51892 void *argp1 = 0 ;
51893 int res1 = 0 ;
51894 int res2 = 0 ;
51895 PyObject * obj0 = 0 ;
51896 PyObject * obj1 = 0 ;
51897 char * kwnames[] = {
51898 (char *) "self",(char *) "item", NULL
51899 };
51900
51901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51903 if (!SWIG_IsOK(res1)) {
51904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51905 }
51906 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51907 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51908 if (!SWIG_IsOK(res2)) {
51909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51910 }
51911 {
51912 PyThreadState* __tstate = wxPyBeginAllowThreads();
51913 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51914 wxPyEndAllowThreads(__tstate);
51915 if (PyErr_Occurred()) SWIG_fail;
51916 }
51917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51918 return resultobj;
51919 fail:
51920 return NULL;
51921 }
51922
51923
51924 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51925 PyObject *resultobj = 0;
51926 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51927 int arg2 ;
51928 int arg3 ;
51929 wxSize result;
51930 void *argp1 = 0 ;
51931 int res1 = 0 ;
51932 int val2 ;
51933 int ecode2 = 0 ;
51934 int val3 ;
51935 int ecode3 = 0 ;
51936 PyObject * obj0 = 0 ;
51937 PyObject * obj1 = 0 ;
51938 PyObject * obj2 = 0 ;
51939 char * kwnames[] = {
51940 (char *) "self",(char *) "row",(char *) "col", NULL
51941 };
51942
51943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51945 if (!SWIG_IsOK(res1)) {
51946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51947 }
51948 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51949 ecode2 = SWIG_AsVal_int(obj1, &val2);
51950 if (!SWIG_IsOK(ecode2)) {
51951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51952 }
51953 arg2 = static_cast< int >(val2);
51954 ecode3 = SWIG_AsVal_int(obj2, &val3);
51955 if (!SWIG_IsOK(ecode3)) {
51956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51957 }
51958 arg3 = static_cast< int >(val3);
51959 {
51960 PyThreadState* __tstate = wxPyBeginAllowThreads();
51961 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51962 wxPyEndAllowThreads(__tstate);
51963 if (PyErr_Occurred()) SWIG_fail;
51964 }
51965 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51966 return resultobj;
51967 fail:
51968 return NULL;
51969 }
51970
51971
51972 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51973 PyObject *resultobj = 0;
51974 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51975 wxSize result;
51976 void *argp1 = 0 ;
51977 int res1 = 0 ;
51978 PyObject *swig_obj[1] ;
51979
51980 if (!args) SWIG_fail;
51981 swig_obj[0] = args;
51982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51983 if (!SWIG_IsOK(res1)) {
51984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51985 }
51986 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51987 {
51988 PyThreadState* __tstate = wxPyBeginAllowThreads();
51989 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51990 wxPyEndAllowThreads(__tstate);
51991 if (PyErr_Occurred()) SWIG_fail;
51992 }
51993 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51994 return resultobj;
51995 fail:
51996 return NULL;
51997 }
51998
51999
52000 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52001 PyObject *resultobj = 0;
52002 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52003 wxSize *arg2 = 0 ;
52004 void *argp1 = 0 ;
52005 int res1 = 0 ;
52006 wxSize temp2 ;
52007 PyObject * obj0 = 0 ;
52008 PyObject * obj1 = 0 ;
52009 char * kwnames[] = {
52010 (char *) "self",(char *) "sz", NULL
52011 };
52012
52013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
52014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52015 if (!SWIG_IsOK(res1)) {
52016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52017 }
52018 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52019 {
52020 arg2 = &temp2;
52021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52022 }
52023 {
52024 PyThreadState* __tstate = wxPyBeginAllowThreads();
52025 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
52026 wxPyEndAllowThreads(__tstate);
52027 if (PyErr_Occurred()) SWIG_fail;
52028 }
52029 resultobj = SWIG_Py_Void();
52030 return resultobj;
52031 fail:
52032 return NULL;
52033 }
52034
52035
52036 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52037 PyObject *resultobj = 0;
52038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52039 wxWindow *arg2 = (wxWindow *) 0 ;
52040 wxGBPosition result;
52041 void *argp1 = 0 ;
52042 int res1 = 0 ;
52043 void *argp2 = 0 ;
52044 int res2 = 0 ;
52045
52046 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52048 if (!SWIG_IsOK(res1)) {
52049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52050 }
52051 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52052 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52053 if (!SWIG_IsOK(res2)) {
52054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52055 }
52056 arg2 = reinterpret_cast< wxWindow * >(argp2);
52057 {
52058 PyThreadState* __tstate = wxPyBeginAllowThreads();
52059 result = (arg1)->GetItemPosition(arg2);
52060 wxPyEndAllowThreads(__tstate);
52061 if (PyErr_Occurred()) SWIG_fail;
52062 }
52063 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52064 return resultobj;
52065 fail:
52066 return NULL;
52067 }
52068
52069
52070 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52071 PyObject *resultobj = 0;
52072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52073 wxSizer *arg2 = (wxSizer *) 0 ;
52074 wxGBPosition result;
52075 void *argp1 = 0 ;
52076 int res1 = 0 ;
52077 void *argp2 = 0 ;
52078 int res2 = 0 ;
52079
52080 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52082 if (!SWIG_IsOK(res1)) {
52083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52084 }
52085 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52086 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52087 if (!SWIG_IsOK(res2)) {
52088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52089 }
52090 arg2 = reinterpret_cast< wxSizer * >(argp2);
52091 {
52092 PyThreadState* __tstate = wxPyBeginAllowThreads();
52093 result = (arg1)->GetItemPosition(arg2);
52094 wxPyEndAllowThreads(__tstate);
52095 if (PyErr_Occurred()) SWIG_fail;
52096 }
52097 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52098 return resultobj;
52099 fail:
52100 return NULL;
52101 }
52102
52103
52104 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52105 PyObject *resultobj = 0;
52106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52107 size_t arg2 ;
52108 wxGBPosition result;
52109 void *argp1 = 0 ;
52110 int res1 = 0 ;
52111 size_t val2 ;
52112 int ecode2 = 0 ;
52113
52114 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52116 if (!SWIG_IsOK(res1)) {
52117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52118 }
52119 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52120 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52121 if (!SWIG_IsOK(ecode2)) {
52122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52123 }
52124 arg2 = static_cast< size_t >(val2);
52125 {
52126 PyThreadState* __tstate = wxPyBeginAllowThreads();
52127 result = (arg1)->GetItemPosition(arg2);
52128 wxPyEndAllowThreads(__tstate);
52129 if (PyErr_Occurred()) SWIG_fail;
52130 }
52131 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52132 return resultobj;
52133 fail:
52134 return NULL;
52135 }
52136
52137
52138 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52139 int argc;
52140 PyObject *argv[3];
52141
52142 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52143 --argc;
52144 if (argc == 2) {
52145 int _v = 0;
52146 {
52147 void *vptr = 0;
52148 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52149 _v = SWIG_CheckState(res);
52150 }
52151 if (!_v) goto check_1;
52152 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52153 }
52154 check_1:
52155
52156 if (argc == 2) {
52157 int _v = 0;
52158 {
52159 void *vptr = 0;
52160 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52161 _v = SWIG_CheckState(res);
52162 }
52163 if (!_v) goto check_2;
52164 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52165 }
52166 check_2:
52167
52168 if (argc == 2) {
52169 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52170 }
52171
52172 fail:
52173 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52174 return NULL;
52175 }
52176
52177
52178 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52179 PyObject *resultobj = 0;
52180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52181 wxWindow *arg2 = (wxWindow *) 0 ;
52182 wxGBPosition *arg3 = 0 ;
52183 bool result;
52184 void *argp1 = 0 ;
52185 int res1 = 0 ;
52186 void *argp2 = 0 ;
52187 int res2 = 0 ;
52188 wxGBPosition temp3 ;
52189
52190 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52192 if (!SWIG_IsOK(res1)) {
52193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52194 }
52195 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52196 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52197 if (!SWIG_IsOK(res2)) {
52198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52199 }
52200 arg2 = reinterpret_cast< wxWindow * >(argp2);
52201 {
52202 arg3 = &temp3;
52203 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52204 }
52205 {
52206 PyThreadState* __tstate = wxPyBeginAllowThreads();
52207 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52208 wxPyEndAllowThreads(__tstate);
52209 if (PyErr_Occurred()) SWIG_fail;
52210 }
52211 {
52212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52213 }
52214 return resultobj;
52215 fail:
52216 return NULL;
52217 }
52218
52219
52220 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52221 PyObject *resultobj = 0;
52222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52223 wxSizer *arg2 = (wxSizer *) 0 ;
52224 wxGBPosition *arg3 = 0 ;
52225 bool result;
52226 void *argp1 = 0 ;
52227 int res1 = 0 ;
52228 void *argp2 = 0 ;
52229 int res2 = 0 ;
52230 wxGBPosition temp3 ;
52231
52232 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52234 if (!SWIG_IsOK(res1)) {
52235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52236 }
52237 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52238 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52239 if (!SWIG_IsOK(res2)) {
52240 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52241 }
52242 arg2 = reinterpret_cast< wxSizer * >(argp2);
52243 {
52244 arg3 = &temp3;
52245 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52246 }
52247 {
52248 PyThreadState* __tstate = wxPyBeginAllowThreads();
52249 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52250 wxPyEndAllowThreads(__tstate);
52251 if (PyErr_Occurred()) SWIG_fail;
52252 }
52253 {
52254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52255 }
52256 return resultobj;
52257 fail:
52258 return NULL;
52259 }
52260
52261
52262 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52263 PyObject *resultobj = 0;
52264 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52265 size_t arg2 ;
52266 wxGBPosition *arg3 = 0 ;
52267 bool result;
52268 void *argp1 = 0 ;
52269 int res1 = 0 ;
52270 size_t val2 ;
52271 int ecode2 = 0 ;
52272 wxGBPosition temp3 ;
52273
52274 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52276 if (!SWIG_IsOK(res1)) {
52277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52278 }
52279 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52280 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52281 if (!SWIG_IsOK(ecode2)) {
52282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52283 }
52284 arg2 = static_cast< size_t >(val2);
52285 {
52286 arg3 = &temp3;
52287 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52288 }
52289 {
52290 PyThreadState* __tstate = wxPyBeginAllowThreads();
52291 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52292 wxPyEndAllowThreads(__tstate);
52293 if (PyErr_Occurred()) SWIG_fail;
52294 }
52295 {
52296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52297 }
52298 return resultobj;
52299 fail:
52300 return NULL;
52301 }
52302
52303
52304 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52305 int argc;
52306 PyObject *argv[4];
52307
52308 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52309 --argc;
52310 if (argc == 3) {
52311 int _v = 0;
52312 {
52313 void *vptr = 0;
52314 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52315 _v = SWIG_CheckState(res);
52316 }
52317 if (!_v) goto check_1;
52318 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52319 }
52320 check_1:
52321
52322 if (argc == 3) {
52323 int _v = 0;
52324 {
52325 void *vptr = 0;
52326 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52327 _v = SWIG_CheckState(res);
52328 }
52329 if (!_v) goto check_2;
52330 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52331 }
52332 check_2:
52333
52334 if (argc == 3) {
52335 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52336 }
52337
52338 fail:
52339 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52340 return NULL;
52341 }
52342
52343
52344 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52345 PyObject *resultobj = 0;
52346 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52347 wxWindow *arg2 = (wxWindow *) 0 ;
52348 wxGBSpan result;
52349 void *argp1 = 0 ;
52350 int res1 = 0 ;
52351 void *argp2 = 0 ;
52352 int res2 = 0 ;
52353
52354 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52356 if (!SWIG_IsOK(res1)) {
52357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52358 }
52359 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52360 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52361 if (!SWIG_IsOK(res2)) {
52362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52363 }
52364 arg2 = reinterpret_cast< wxWindow * >(argp2);
52365 {
52366 PyThreadState* __tstate = wxPyBeginAllowThreads();
52367 result = (arg1)->GetItemSpan(arg2);
52368 wxPyEndAllowThreads(__tstate);
52369 if (PyErr_Occurred()) SWIG_fail;
52370 }
52371 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52372 return resultobj;
52373 fail:
52374 return NULL;
52375 }
52376
52377
52378 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52379 PyObject *resultobj = 0;
52380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52381 wxSizer *arg2 = (wxSizer *) 0 ;
52382 wxGBSpan result;
52383 void *argp1 = 0 ;
52384 int res1 = 0 ;
52385 void *argp2 = 0 ;
52386 int res2 = 0 ;
52387
52388 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52390 if (!SWIG_IsOK(res1)) {
52391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52392 }
52393 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52394 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52395 if (!SWIG_IsOK(res2)) {
52396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52397 }
52398 arg2 = reinterpret_cast< wxSizer * >(argp2);
52399 {
52400 PyThreadState* __tstate = wxPyBeginAllowThreads();
52401 result = (arg1)->GetItemSpan(arg2);
52402 wxPyEndAllowThreads(__tstate);
52403 if (PyErr_Occurred()) SWIG_fail;
52404 }
52405 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52406 return resultobj;
52407 fail:
52408 return NULL;
52409 }
52410
52411
52412 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52413 PyObject *resultobj = 0;
52414 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52415 size_t arg2 ;
52416 wxGBSpan result;
52417 void *argp1 = 0 ;
52418 int res1 = 0 ;
52419 size_t val2 ;
52420 int ecode2 = 0 ;
52421
52422 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52424 if (!SWIG_IsOK(res1)) {
52425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52426 }
52427 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52428 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52429 if (!SWIG_IsOK(ecode2)) {
52430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52431 }
52432 arg2 = static_cast< size_t >(val2);
52433 {
52434 PyThreadState* __tstate = wxPyBeginAllowThreads();
52435 result = (arg1)->GetItemSpan(arg2);
52436 wxPyEndAllowThreads(__tstate);
52437 if (PyErr_Occurred()) SWIG_fail;
52438 }
52439 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52440 return resultobj;
52441 fail:
52442 return NULL;
52443 }
52444
52445
52446 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52447 int argc;
52448 PyObject *argv[3];
52449
52450 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52451 --argc;
52452 if (argc == 2) {
52453 int _v = 0;
52454 {
52455 void *vptr = 0;
52456 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52457 _v = SWIG_CheckState(res);
52458 }
52459 if (!_v) goto check_1;
52460 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52461 }
52462 check_1:
52463
52464 if (argc == 2) {
52465 int _v = 0;
52466 {
52467 void *vptr = 0;
52468 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52469 _v = SWIG_CheckState(res);
52470 }
52471 if (!_v) goto check_2;
52472 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52473 }
52474 check_2:
52475
52476 if (argc == 2) {
52477 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52478 }
52479
52480 fail:
52481 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52482 return NULL;
52483 }
52484
52485
52486 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52487 PyObject *resultobj = 0;
52488 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52489 wxWindow *arg2 = (wxWindow *) 0 ;
52490 wxGBSpan *arg3 = 0 ;
52491 bool result;
52492 void *argp1 = 0 ;
52493 int res1 = 0 ;
52494 void *argp2 = 0 ;
52495 int res2 = 0 ;
52496 wxGBSpan temp3 ;
52497
52498 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52500 if (!SWIG_IsOK(res1)) {
52501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52502 }
52503 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52504 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52505 if (!SWIG_IsOK(res2)) {
52506 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52507 }
52508 arg2 = reinterpret_cast< wxWindow * >(argp2);
52509 {
52510 arg3 = &temp3;
52511 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52512 }
52513 {
52514 PyThreadState* __tstate = wxPyBeginAllowThreads();
52515 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52516 wxPyEndAllowThreads(__tstate);
52517 if (PyErr_Occurred()) SWIG_fail;
52518 }
52519 {
52520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52521 }
52522 return resultobj;
52523 fail:
52524 return NULL;
52525 }
52526
52527
52528 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52529 PyObject *resultobj = 0;
52530 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52531 wxSizer *arg2 = (wxSizer *) 0 ;
52532 wxGBSpan *arg3 = 0 ;
52533 bool result;
52534 void *argp1 = 0 ;
52535 int res1 = 0 ;
52536 void *argp2 = 0 ;
52537 int res2 = 0 ;
52538 wxGBSpan temp3 ;
52539
52540 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52542 if (!SWIG_IsOK(res1)) {
52543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52544 }
52545 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52546 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52547 if (!SWIG_IsOK(res2)) {
52548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52549 }
52550 arg2 = reinterpret_cast< wxSizer * >(argp2);
52551 {
52552 arg3 = &temp3;
52553 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52554 }
52555 {
52556 PyThreadState* __tstate = wxPyBeginAllowThreads();
52557 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52558 wxPyEndAllowThreads(__tstate);
52559 if (PyErr_Occurred()) SWIG_fail;
52560 }
52561 {
52562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52563 }
52564 return resultobj;
52565 fail:
52566 return NULL;
52567 }
52568
52569
52570 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52571 PyObject *resultobj = 0;
52572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52573 size_t arg2 ;
52574 wxGBSpan *arg3 = 0 ;
52575 bool result;
52576 void *argp1 = 0 ;
52577 int res1 = 0 ;
52578 size_t val2 ;
52579 int ecode2 = 0 ;
52580 wxGBSpan temp3 ;
52581
52582 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52584 if (!SWIG_IsOK(res1)) {
52585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52586 }
52587 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52588 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52589 if (!SWIG_IsOK(ecode2)) {
52590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52591 }
52592 arg2 = static_cast< size_t >(val2);
52593 {
52594 arg3 = &temp3;
52595 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52596 }
52597 {
52598 PyThreadState* __tstate = wxPyBeginAllowThreads();
52599 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52600 wxPyEndAllowThreads(__tstate);
52601 if (PyErr_Occurred()) SWIG_fail;
52602 }
52603 {
52604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52605 }
52606 return resultobj;
52607 fail:
52608 return NULL;
52609 }
52610
52611
52612 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52613 int argc;
52614 PyObject *argv[4];
52615
52616 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52617 --argc;
52618 if (argc == 3) {
52619 int _v = 0;
52620 {
52621 void *vptr = 0;
52622 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52623 _v = SWIG_CheckState(res);
52624 }
52625 if (!_v) goto check_1;
52626 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52627 }
52628 check_1:
52629
52630 if (argc == 3) {
52631 int _v = 0;
52632 {
52633 void *vptr = 0;
52634 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52635 _v = SWIG_CheckState(res);
52636 }
52637 if (!_v) goto check_2;
52638 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52639 }
52640 check_2:
52641
52642 if (argc == 3) {
52643 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52644 }
52645
52646 fail:
52647 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52648 return NULL;
52649 }
52650
52651
52652 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52653 PyObject *resultobj = 0;
52654 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52655 wxWindow *arg2 = (wxWindow *) 0 ;
52656 wxGBSizerItem *result = 0 ;
52657 void *argp1 = 0 ;
52658 int res1 = 0 ;
52659 void *argp2 = 0 ;
52660 int res2 = 0 ;
52661
52662 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52664 if (!SWIG_IsOK(res1)) {
52665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52666 }
52667 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52668 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52669 if (!SWIG_IsOK(res2)) {
52670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52671 }
52672 arg2 = reinterpret_cast< wxWindow * >(argp2);
52673 {
52674 PyThreadState* __tstate = wxPyBeginAllowThreads();
52675 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52676 wxPyEndAllowThreads(__tstate);
52677 if (PyErr_Occurred()) SWIG_fail;
52678 }
52679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52680 return resultobj;
52681 fail:
52682 return NULL;
52683 }
52684
52685
52686 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52687 PyObject *resultobj = 0;
52688 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52689 wxSizer *arg2 = (wxSizer *) 0 ;
52690 wxGBSizerItem *result = 0 ;
52691 void *argp1 = 0 ;
52692 int res1 = 0 ;
52693 void *argp2 = 0 ;
52694 int res2 = 0 ;
52695
52696 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52698 if (!SWIG_IsOK(res1)) {
52699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52700 }
52701 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52702 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52703 if (!SWIG_IsOK(res2)) {
52704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52705 }
52706 arg2 = reinterpret_cast< wxSizer * >(argp2);
52707 {
52708 PyThreadState* __tstate = wxPyBeginAllowThreads();
52709 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52710 wxPyEndAllowThreads(__tstate);
52711 if (PyErr_Occurred()) SWIG_fail;
52712 }
52713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52714 return resultobj;
52715 fail:
52716 return NULL;
52717 }
52718
52719
52720 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52721 int argc;
52722 PyObject *argv[3];
52723
52724 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52725 --argc;
52726 if (argc == 2) {
52727 int _v = 0;
52728 {
52729 void *vptr = 0;
52730 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52731 _v = SWIG_CheckState(res);
52732 }
52733 if (!_v) goto check_1;
52734 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52735 }
52736 check_1:
52737
52738 if (argc == 2) {
52739 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52740 }
52741
52742 fail:
52743 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52744 return NULL;
52745 }
52746
52747
52748 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52749 PyObject *resultobj = 0;
52750 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52751 wxGBPosition *arg2 = 0 ;
52752 wxGBSizerItem *result = 0 ;
52753 void *argp1 = 0 ;
52754 int res1 = 0 ;
52755 wxGBPosition temp2 ;
52756 PyObject * obj0 = 0 ;
52757 PyObject * obj1 = 0 ;
52758 char * kwnames[] = {
52759 (char *) "self",(char *) "pos", NULL
52760 };
52761
52762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52764 if (!SWIG_IsOK(res1)) {
52765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52766 }
52767 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52768 {
52769 arg2 = &temp2;
52770 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52771 }
52772 {
52773 PyThreadState* __tstate = wxPyBeginAllowThreads();
52774 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52775 wxPyEndAllowThreads(__tstate);
52776 if (PyErr_Occurred()) SWIG_fail;
52777 }
52778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52779 return resultobj;
52780 fail:
52781 return NULL;
52782 }
52783
52784
52785 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52786 PyObject *resultobj = 0;
52787 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52788 wxPoint *arg2 = 0 ;
52789 wxGBSizerItem *result = 0 ;
52790 void *argp1 = 0 ;
52791 int res1 = 0 ;
52792 wxPoint temp2 ;
52793 PyObject * obj0 = 0 ;
52794 PyObject * obj1 = 0 ;
52795 char * kwnames[] = {
52796 (char *) "self",(char *) "pt", NULL
52797 };
52798
52799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52801 if (!SWIG_IsOK(res1)) {
52802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52803 }
52804 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52805 {
52806 arg2 = &temp2;
52807 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52808 }
52809 {
52810 PyThreadState* __tstate = wxPyBeginAllowThreads();
52811 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52812 wxPyEndAllowThreads(__tstate);
52813 if (PyErr_Occurred()) SWIG_fail;
52814 }
52815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52816 return resultobj;
52817 fail:
52818 return NULL;
52819 }
52820
52821
52822 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52823 PyObject *resultobj = 0;
52824 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52825 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52826 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52827 bool result;
52828 void *argp1 = 0 ;
52829 int res1 = 0 ;
52830 void *argp2 = 0 ;
52831 int res2 = 0 ;
52832 void *argp3 = 0 ;
52833 int res3 = 0 ;
52834 PyObject * obj0 = 0 ;
52835 PyObject * obj1 = 0 ;
52836 PyObject * obj2 = 0 ;
52837 char * kwnames[] = {
52838 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52839 };
52840
52841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52843 if (!SWIG_IsOK(res1)) {
52844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52845 }
52846 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52847 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52848 if (!SWIG_IsOK(res2)) {
52849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52850 }
52851 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52852 if (obj2) {
52853 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52854 if (!SWIG_IsOK(res3)) {
52855 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52856 }
52857 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52858 }
52859 {
52860 PyThreadState* __tstate = wxPyBeginAllowThreads();
52861 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52862 wxPyEndAllowThreads(__tstate);
52863 if (PyErr_Occurred()) SWIG_fail;
52864 }
52865 {
52866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52867 }
52868 return resultobj;
52869 fail:
52870 return NULL;
52871 }
52872
52873
52874 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52875 PyObject *resultobj = 0;
52876 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52877 wxGBPosition *arg2 = 0 ;
52878 wxGBSpan *arg3 = 0 ;
52879 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52880 bool result;
52881 void *argp1 = 0 ;
52882 int res1 = 0 ;
52883 wxGBPosition temp2 ;
52884 wxGBSpan temp3 ;
52885 void *argp4 = 0 ;
52886 int res4 = 0 ;
52887 PyObject * obj0 = 0 ;
52888 PyObject * obj1 = 0 ;
52889 PyObject * obj2 = 0 ;
52890 PyObject * obj3 = 0 ;
52891 char * kwnames[] = {
52892 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52893 };
52894
52895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52897 if (!SWIG_IsOK(res1)) {
52898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52899 }
52900 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52901 {
52902 arg2 = &temp2;
52903 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52904 }
52905 {
52906 arg3 = &temp3;
52907 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52908 }
52909 if (obj3) {
52910 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52911 if (!SWIG_IsOK(res4)) {
52912 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52913 }
52914 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52915 }
52916 {
52917 PyThreadState* __tstate = wxPyBeginAllowThreads();
52918 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52919 wxPyEndAllowThreads(__tstate);
52920 if (PyErr_Occurred()) SWIG_fail;
52921 }
52922 {
52923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52924 }
52925 return resultobj;
52926 fail:
52927 return NULL;
52928 }
52929
52930
52931 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52932 PyObject *obj;
52933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52934 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52935 return SWIG_Py_Void();
52936 }
52937
52938 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52939 return SWIG_Python_InitShadowInstance(args);
52940 }
52941
52942 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52943 PyObject *resultobj = 0;
52944 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52945 wxRelationship arg2 ;
52946 wxWindow *arg3 = (wxWindow *) 0 ;
52947 wxEdge arg4 ;
52948 int arg5 = (int) 0 ;
52949 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52950 void *argp1 = 0 ;
52951 int res1 = 0 ;
52952 int val2 ;
52953 int ecode2 = 0 ;
52954 void *argp3 = 0 ;
52955 int res3 = 0 ;
52956 int val4 ;
52957 int ecode4 = 0 ;
52958 int val5 ;
52959 int ecode5 = 0 ;
52960 int val6 ;
52961 int ecode6 = 0 ;
52962 PyObject * obj0 = 0 ;
52963 PyObject * obj1 = 0 ;
52964 PyObject * obj2 = 0 ;
52965 PyObject * obj3 = 0 ;
52966 PyObject * obj4 = 0 ;
52967 PyObject * obj5 = 0 ;
52968 char * kwnames[] = {
52969 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52970 };
52971
52972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52974 if (!SWIG_IsOK(res1)) {
52975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52976 }
52977 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52978 ecode2 = SWIG_AsVal_int(obj1, &val2);
52979 if (!SWIG_IsOK(ecode2)) {
52980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52981 }
52982 arg2 = static_cast< wxRelationship >(val2);
52983 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52984 if (!SWIG_IsOK(res3)) {
52985 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52986 }
52987 arg3 = reinterpret_cast< wxWindow * >(argp3);
52988 ecode4 = SWIG_AsVal_int(obj3, &val4);
52989 if (!SWIG_IsOK(ecode4)) {
52990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52991 }
52992 arg4 = static_cast< wxEdge >(val4);
52993 if (obj4) {
52994 ecode5 = SWIG_AsVal_int(obj4, &val5);
52995 if (!SWIG_IsOK(ecode5)) {
52996 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52997 }
52998 arg5 = static_cast< int >(val5);
52999 }
53000 if (obj5) {
53001 ecode6 = SWIG_AsVal_int(obj5, &val6);
53002 if (!SWIG_IsOK(ecode6)) {
53003 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
53004 }
53005 arg6 = static_cast< int >(val6);
53006 }
53007 {
53008 PyThreadState* __tstate = wxPyBeginAllowThreads();
53009 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
53010 wxPyEndAllowThreads(__tstate);
53011 if (PyErr_Occurred()) SWIG_fail;
53012 }
53013 resultobj = SWIG_Py_Void();
53014 return resultobj;
53015 fail:
53016 return NULL;
53017 }
53018
53019
53020 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53021 PyObject *resultobj = 0;
53022 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53023 wxWindow *arg2 = (wxWindow *) 0 ;
53024 int arg3 = (int) 0 ;
53025 void *argp1 = 0 ;
53026 int res1 = 0 ;
53027 void *argp2 = 0 ;
53028 int res2 = 0 ;
53029 int val3 ;
53030 int ecode3 = 0 ;
53031 PyObject * obj0 = 0 ;
53032 PyObject * obj1 = 0 ;
53033 PyObject * obj2 = 0 ;
53034 char * kwnames[] = {
53035 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53036 };
53037
53038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53040 if (!SWIG_IsOK(res1)) {
53041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53042 }
53043 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53045 if (!SWIG_IsOK(res2)) {
53046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53047 }
53048 arg2 = reinterpret_cast< wxWindow * >(argp2);
53049 if (obj2) {
53050 ecode3 = SWIG_AsVal_int(obj2, &val3);
53051 if (!SWIG_IsOK(ecode3)) {
53052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53053 }
53054 arg3 = static_cast< int >(val3);
53055 }
53056 {
53057 PyThreadState* __tstate = wxPyBeginAllowThreads();
53058 (arg1)->LeftOf(arg2,arg3);
53059 wxPyEndAllowThreads(__tstate);
53060 if (PyErr_Occurred()) SWIG_fail;
53061 }
53062 resultobj = SWIG_Py_Void();
53063 return resultobj;
53064 fail:
53065 return NULL;
53066 }
53067
53068
53069 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53070 PyObject *resultobj = 0;
53071 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53072 wxWindow *arg2 = (wxWindow *) 0 ;
53073 int arg3 = (int) 0 ;
53074 void *argp1 = 0 ;
53075 int res1 = 0 ;
53076 void *argp2 = 0 ;
53077 int res2 = 0 ;
53078 int val3 ;
53079 int ecode3 = 0 ;
53080 PyObject * obj0 = 0 ;
53081 PyObject * obj1 = 0 ;
53082 PyObject * obj2 = 0 ;
53083 char * kwnames[] = {
53084 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53085 };
53086
53087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53089 if (!SWIG_IsOK(res1)) {
53090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53091 }
53092 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53094 if (!SWIG_IsOK(res2)) {
53095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53096 }
53097 arg2 = reinterpret_cast< wxWindow * >(argp2);
53098 if (obj2) {
53099 ecode3 = SWIG_AsVal_int(obj2, &val3);
53100 if (!SWIG_IsOK(ecode3)) {
53101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53102 }
53103 arg3 = static_cast< int >(val3);
53104 }
53105 {
53106 PyThreadState* __tstate = wxPyBeginAllowThreads();
53107 (arg1)->RightOf(arg2,arg3);
53108 wxPyEndAllowThreads(__tstate);
53109 if (PyErr_Occurred()) SWIG_fail;
53110 }
53111 resultobj = SWIG_Py_Void();
53112 return resultobj;
53113 fail:
53114 return NULL;
53115 }
53116
53117
53118 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53119 PyObject *resultobj = 0;
53120 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53121 wxWindow *arg2 = (wxWindow *) 0 ;
53122 int arg3 = (int) 0 ;
53123 void *argp1 = 0 ;
53124 int res1 = 0 ;
53125 void *argp2 = 0 ;
53126 int res2 = 0 ;
53127 int val3 ;
53128 int ecode3 = 0 ;
53129 PyObject * obj0 = 0 ;
53130 PyObject * obj1 = 0 ;
53131 PyObject * obj2 = 0 ;
53132 char * kwnames[] = {
53133 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53134 };
53135
53136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53138 if (!SWIG_IsOK(res1)) {
53139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53140 }
53141 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53143 if (!SWIG_IsOK(res2)) {
53144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53145 }
53146 arg2 = reinterpret_cast< wxWindow * >(argp2);
53147 if (obj2) {
53148 ecode3 = SWIG_AsVal_int(obj2, &val3);
53149 if (!SWIG_IsOK(ecode3)) {
53150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53151 }
53152 arg3 = static_cast< int >(val3);
53153 }
53154 {
53155 PyThreadState* __tstate = wxPyBeginAllowThreads();
53156 (arg1)->Above(arg2,arg3);
53157 wxPyEndAllowThreads(__tstate);
53158 if (PyErr_Occurred()) SWIG_fail;
53159 }
53160 resultobj = SWIG_Py_Void();
53161 return resultobj;
53162 fail:
53163 return NULL;
53164 }
53165
53166
53167 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53168 PyObject *resultobj = 0;
53169 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53170 wxWindow *arg2 = (wxWindow *) 0 ;
53171 int arg3 = (int) 0 ;
53172 void *argp1 = 0 ;
53173 int res1 = 0 ;
53174 void *argp2 = 0 ;
53175 int res2 = 0 ;
53176 int val3 ;
53177 int ecode3 = 0 ;
53178 PyObject * obj0 = 0 ;
53179 PyObject * obj1 = 0 ;
53180 PyObject * obj2 = 0 ;
53181 char * kwnames[] = {
53182 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53183 };
53184
53185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53187 if (!SWIG_IsOK(res1)) {
53188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53189 }
53190 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53192 if (!SWIG_IsOK(res2)) {
53193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53194 }
53195 arg2 = reinterpret_cast< wxWindow * >(argp2);
53196 if (obj2) {
53197 ecode3 = SWIG_AsVal_int(obj2, &val3);
53198 if (!SWIG_IsOK(ecode3)) {
53199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53200 }
53201 arg3 = static_cast< int >(val3);
53202 }
53203 {
53204 PyThreadState* __tstate = wxPyBeginAllowThreads();
53205 (arg1)->Below(arg2,arg3);
53206 wxPyEndAllowThreads(__tstate);
53207 if (PyErr_Occurred()) SWIG_fail;
53208 }
53209 resultobj = SWIG_Py_Void();
53210 return resultobj;
53211 fail:
53212 return NULL;
53213 }
53214
53215
53216 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53217 PyObject *resultobj = 0;
53218 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53219 wxWindow *arg2 = (wxWindow *) 0 ;
53220 wxEdge arg3 ;
53221 int arg4 = (int) 0 ;
53222 void *argp1 = 0 ;
53223 int res1 = 0 ;
53224 void *argp2 = 0 ;
53225 int res2 = 0 ;
53226 int val3 ;
53227 int ecode3 = 0 ;
53228 int val4 ;
53229 int ecode4 = 0 ;
53230 PyObject * obj0 = 0 ;
53231 PyObject * obj1 = 0 ;
53232 PyObject * obj2 = 0 ;
53233 PyObject * obj3 = 0 ;
53234 char * kwnames[] = {
53235 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53236 };
53237
53238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53240 if (!SWIG_IsOK(res1)) {
53241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53242 }
53243 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53244 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53245 if (!SWIG_IsOK(res2)) {
53246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53247 }
53248 arg2 = reinterpret_cast< wxWindow * >(argp2);
53249 ecode3 = SWIG_AsVal_int(obj2, &val3);
53250 if (!SWIG_IsOK(ecode3)) {
53251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53252 }
53253 arg3 = static_cast< wxEdge >(val3);
53254 if (obj3) {
53255 ecode4 = SWIG_AsVal_int(obj3, &val4);
53256 if (!SWIG_IsOK(ecode4)) {
53257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53258 }
53259 arg4 = static_cast< int >(val4);
53260 }
53261 {
53262 PyThreadState* __tstate = wxPyBeginAllowThreads();
53263 (arg1)->SameAs(arg2,arg3,arg4);
53264 wxPyEndAllowThreads(__tstate);
53265 if (PyErr_Occurred()) SWIG_fail;
53266 }
53267 resultobj = SWIG_Py_Void();
53268 return resultobj;
53269 fail:
53270 return NULL;
53271 }
53272
53273
53274 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53275 PyObject *resultobj = 0;
53276 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53277 wxWindow *arg2 = (wxWindow *) 0 ;
53278 wxEdge arg3 ;
53279 int arg4 ;
53280 void *argp1 = 0 ;
53281 int res1 = 0 ;
53282 void *argp2 = 0 ;
53283 int res2 = 0 ;
53284 int val3 ;
53285 int ecode3 = 0 ;
53286 int val4 ;
53287 int ecode4 = 0 ;
53288 PyObject * obj0 = 0 ;
53289 PyObject * obj1 = 0 ;
53290 PyObject * obj2 = 0 ;
53291 PyObject * obj3 = 0 ;
53292 char * kwnames[] = {
53293 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53294 };
53295
53296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53298 if (!SWIG_IsOK(res1)) {
53299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53300 }
53301 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53303 if (!SWIG_IsOK(res2)) {
53304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53305 }
53306 arg2 = reinterpret_cast< wxWindow * >(argp2);
53307 ecode3 = SWIG_AsVal_int(obj2, &val3);
53308 if (!SWIG_IsOK(ecode3)) {
53309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53310 }
53311 arg3 = static_cast< wxEdge >(val3);
53312 ecode4 = SWIG_AsVal_int(obj3, &val4);
53313 if (!SWIG_IsOK(ecode4)) {
53314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53315 }
53316 arg4 = static_cast< int >(val4);
53317 {
53318 PyThreadState* __tstate = wxPyBeginAllowThreads();
53319 (arg1)->PercentOf(arg2,arg3,arg4);
53320 wxPyEndAllowThreads(__tstate);
53321 if (PyErr_Occurred()) SWIG_fail;
53322 }
53323 resultobj = SWIG_Py_Void();
53324 return resultobj;
53325 fail:
53326 return NULL;
53327 }
53328
53329
53330 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53331 PyObject *resultobj = 0;
53332 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53333 int arg2 ;
53334 void *argp1 = 0 ;
53335 int res1 = 0 ;
53336 int val2 ;
53337 int ecode2 = 0 ;
53338 PyObject * obj0 = 0 ;
53339 PyObject * obj1 = 0 ;
53340 char * kwnames[] = {
53341 (char *) "self",(char *) "val", NULL
53342 };
53343
53344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53346 if (!SWIG_IsOK(res1)) {
53347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53348 }
53349 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53350 ecode2 = SWIG_AsVal_int(obj1, &val2);
53351 if (!SWIG_IsOK(ecode2)) {
53352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53353 }
53354 arg2 = static_cast< int >(val2);
53355 {
53356 PyThreadState* __tstate = wxPyBeginAllowThreads();
53357 (arg1)->Absolute(arg2);
53358 wxPyEndAllowThreads(__tstate);
53359 if (PyErr_Occurred()) SWIG_fail;
53360 }
53361 resultobj = SWIG_Py_Void();
53362 return resultobj;
53363 fail:
53364 return NULL;
53365 }
53366
53367
53368 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53369 PyObject *resultobj = 0;
53370 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53371 void *argp1 = 0 ;
53372 int res1 = 0 ;
53373 PyObject *swig_obj[1] ;
53374
53375 if (!args) SWIG_fail;
53376 swig_obj[0] = args;
53377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53378 if (!SWIG_IsOK(res1)) {
53379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53380 }
53381 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53382 {
53383 PyThreadState* __tstate = wxPyBeginAllowThreads();
53384 (arg1)->Unconstrained();
53385 wxPyEndAllowThreads(__tstate);
53386 if (PyErr_Occurred()) SWIG_fail;
53387 }
53388 resultobj = SWIG_Py_Void();
53389 return resultobj;
53390 fail:
53391 return NULL;
53392 }
53393
53394
53395 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53396 PyObject *resultobj = 0;
53397 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53398 void *argp1 = 0 ;
53399 int res1 = 0 ;
53400 PyObject *swig_obj[1] ;
53401
53402 if (!args) SWIG_fail;
53403 swig_obj[0] = args;
53404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53405 if (!SWIG_IsOK(res1)) {
53406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53407 }
53408 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53409 {
53410 PyThreadState* __tstate = wxPyBeginAllowThreads();
53411 (arg1)->AsIs();
53412 wxPyEndAllowThreads(__tstate);
53413 if (PyErr_Occurred()) SWIG_fail;
53414 }
53415 resultobj = SWIG_Py_Void();
53416 return resultobj;
53417 fail:
53418 return NULL;
53419 }
53420
53421
53422 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53423 PyObject *resultobj = 0;
53424 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53425 wxWindow *result = 0 ;
53426 void *argp1 = 0 ;
53427 int res1 = 0 ;
53428 PyObject *swig_obj[1] ;
53429
53430 if (!args) SWIG_fail;
53431 swig_obj[0] = args;
53432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53433 if (!SWIG_IsOK(res1)) {
53434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53435 }
53436 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53437 {
53438 PyThreadState* __tstate = wxPyBeginAllowThreads();
53439 result = (wxWindow *)(arg1)->GetOtherWindow();
53440 wxPyEndAllowThreads(__tstate);
53441 if (PyErr_Occurred()) SWIG_fail;
53442 }
53443 {
53444 resultobj = wxPyMake_wxObject(result, 0);
53445 }
53446 return resultobj;
53447 fail:
53448 return NULL;
53449 }
53450
53451
53452 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53453 PyObject *resultobj = 0;
53454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53455 wxEdge result;
53456 void *argp1 = 0 ;
53457 int res1 = 0 ;
53458 PyObject *swig_obj[1] ;
53459
53460 if (!args) SWIG_fail;
53461 swig_obj[0] = args;
53462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53463 if (!SWIG_IsOK(res1)) {
53464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53465 }
53466 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53467 {
53468 PyThreadState* __tstate = wxPyBeginAllowThreads();
53469 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53470 wxPyEndAllowThreads(__tstate);
53471 if (PyErr_Occurred()) SWIG_fail;
53472 }
53473 resultobj = SWIG_From_int(static_cast< int >(result));
53474 return resultobj;
53475 fail:
53476 return NULL;
53477 }
53478
53479
53480 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53481 PyObject *resultobj = 0;
53482 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53483 wxEdge arg2 ;
53484 void *argp1 = 0 ;
53485 int res1 = 0 ;
53486 int val2 ;
53487 int ecode2 = 0 ;
53488 PyObject * obj0 = 0 ;
53489 PyObject * obj1 = 0 ;
53490 char * kwnames[] = {
53491 (char *) "self",(char *) "which", NULL
53492 };
53493
53494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53496 if (!SWIG_IsOK(res1)) {
53497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53498 }
53499 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53500 ecode2 = SWIG_AsVal_int(obj1, &val2);
53501 if (!SWIG_IsOK(ecode2)) {
53502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53503 }
53504 arg2 = static_cast< wxEdge >(val2);
53505 {
53506 PyThreadState* __tstate = wxPyBeginAllowThreads();
53507 (arg1)->SetEdge(arg2);
53508 wxPyEndAllowThreads(__tstate);
53509 if (PyErr_Occurred()) SWIG_fail;
53510 }
53511 resultobj = SWIG_Py_Void();
53512 return resultobj;
53513 fail:
53514 return NULL;
53515 }
53516
53517
53518 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53519 PyObject *resultobj = 0;
53520 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53521 int arg2 ;
53522 void *argp1 = 0 ;
53523 int res1 = 0 ;
53524 int val2 ;
53525 int ecode2 = 0 ;
53526 PyObject * obj0 = 0 ;
53527 PyObject * obj1 = 0 ;
53528 char * kwnames[] = {
53529 (char *) "self",(char *) "v", NULL
53530 };
53531
53532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53534 if (!SWIG_IsOK(res1)) {
53535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53536 }
53537 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53538 ecode2 = SWIG_AsVal_int(obj1, &val2);
53539 if (!SWIG_IsOK(ecode2)) {
53540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53541 }
53542 arg2 = static_cast< int >(val2);
53543 {
53544 PyThreadState* __tstate = wxPyBeginAllowThreads();
53545 (arg1)->SetValue(arg2);
53546 wxPyEndAllowThreads(__tstate);
53547 if (PyErr_Occurred()) SWIG_fail;
53548 }
53549 resultobj = SWIG_Py_Void();
53550 return resultobj;
53551 fail:
53552 return NULL;
53553 }
53554
53555
53556 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53557 PyObject *resultobj = 0;
53558 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53559 int result;
53560 void *argp1 = 0 ;
53561 int res1 = 0 ;
53562 PyObject *swig_obj[1] ;
53563
53564 if (!args) SWIG_fail;
53565 swig_obj[0] = args;
53566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53567 if (!SWIG_IsOK(res1)) {
53568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53569 }
53570 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53571 {
53572 PyThreadState* __tstate = wxPyBeginAllowThreads();
53573 result = (int)(arg1)->GetMargin();
53574 wxPyEndAllowThreads(__tstate);
53575 if (PyErr_Occurred()) SWIG_fail;
53576 }
53577 resultobj = SWIG_From_int(static_cast< int >(result));
53578 return resultobj;
53579 fail:
53580 return NULL;
53581 }
53582
53583
53584 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53585 PyObject *resultobj = 0;
53586 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53587 int arg2 ;
53588 void *argp1 = 0 ;
53589 int res1 = 0 ;
53590 int val2 ;
53591 int ecode2 = 0 ;
53592 PyObject * obj0 = 0 ;
53593 PyObject * obj1 = 0 ;
53594 char * kwnames[] = {
53595 (char *) "self",(char *) "m", NULL
53596 };
53597
53598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53600 if (!SWIG_IsOK(res1)) {
53601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53602 }
53603 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53604 ecode2 = SWIG_AsVal_int(obj1, &val2);
53605 if (!SWIG_IsOK(ecode2)) {
53606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53607 }
53608 arg2 = static_cast< int >(val2);
53609 {
53610 PyThreadState* __tstate = wxPyBeginAllowThreads();
53611 (arg1)->SetMargin(arg2);
53612 wxPyEndAllowThreads(__tstate);
53613 if (PyErr_Occurred()) SWIG_fail;
53614 }
53615 resultobj = SWIG_Py_Void();
53616 return resultobj;
53617 fail:
53618 return NULL;
53619 }
53620
53621
53622 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53623 PyObject *resultobj = 0;
53624 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53625 int result;
53626 void *argp1 = 0 ;
53627 int res1 = 0 ;
53628 PyObject *swig_obj[1] ;
53629
53630 if (!args) SWIG_fail;
53631 swig_obj[0] = args;
53632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53633 if (!SWIG_IsOK(res1)) {
53634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53635 }
53636 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53637 {
53638 PyThreadState* __tstate = wxPyBeginAllowThreads();
53639 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53640 wxPyEndAllowThreads(__tstate);
53641 if (PyErr_Occurred()) SWIG_fail;
53642 }
53643 resultobj = SWIG_From_int(static_cast< int >(result));
53644 return resultobj;
53645 fail:
53646 return NULL;
53647 }
53648
53649
53650 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53651 PyObject *resultobj = 0;
53652 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53653 int result;
53654 void *argp1 = 0 ;
53655 int res1 = 0 ;
53656 PyObject *swig_obj[1] ;
53657
53658 if (!args) SWIG_fail;
53659 swig_obj[0] = args;
53660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53661 if (!SWIG_IsOK(res1)) {
53662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53663 }
53664 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53665 {
53666 PyThreadState* __tstate = wxPyBeginAllowThreads();
53667 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53668 wxPyEndAllowThreads(__tstate);
53669 if (PyErr_Occurred()) SWIG_fail;
53670 }
53671 resultobj = SWIG_From_int(static_cast< int >(result));
53672 return resultobj;
53673 fail:
53674 return NULL;
53675 }
53676
53677
53678 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53679 PyObject *resultobj = 0;
53680 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53681 int result;
53682 void *argp1 = 0 ;
53683 int res1 = 0 ;
53684 PyObject *swig_obj[1] ;
53685
53686 if (!args) SWIG_fail;
53687 swig_obj[0] = args;
53688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53689 if (!SWIG_IsOK(res1)) {
53690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53691 }
53692 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53693 {
53694 PyThreadState* __tstate = wxPyBeginAllowThreads();
53695 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53696 wxPyEndAllowThreads(__tstate);
53697 if (PyErr_Occurred()) SWIG_fail;
53698 }
53699 resultobj = SWIG_From_int(static_cast< int >(result));
53700 return resultobj;
53701 fail:
53702 return NULL;
53703 }
53704
53705
53706 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53707 PyObject *resultobj = 0;
53708 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53709 bool result;
53710 void *argp1 = 0 ;
53711 int res1 = 0 ;
53712 PyObject *swig_obj[1] ;
53713
53714 if (!args) SWIG_fail;
53715 swig_obj[0] = args;
53716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53717 if (!SWIG_IsOK(res1)) {
53718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53719 }
53720 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53721 {
53722 PyThreadState* __tstate = wxPyBeginAllowThreads();
53723 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53724 wxPyEndAllowThreads(__tstate);
53725 if (PyErr_Occurred()) SWIG_fail;
53726 }
53727 {
53728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53729 }
53730 return resultobj;
53731 fail:
53732 return NULL;
53733 }
53734
53735
53736 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53737 PyObject *resultobj = 0;
53738 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53739 bool arg2 ;
53740 void *argp1 = 0 ;
53741 int res1 = 0 ;
53742 bool val2 ;
53743 int ecode2 = 0 ;
53744 PyObject * obj0 = 0 ;
53745 PyObject * obj1 = 0 ;
53746 char * kwnames[] = {
53747 (char *) "self",(char *) "d", NULL
53748 };
53749
53750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53752 if (!SWIG_IsOK(res1)) {
53753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53754 }
53755 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53756 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53757 if (!SWIG_IsOK(ecode2)) {
53758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53759 }
53760 arg2 = static_cast< bool >(val2);
53761 {
53762 PyThreadState* __tstate = wxPyBeginAllowThreads();
53763 (arg1)->SetDone(arg2);
53764 wxPyEndAllowThreads(__tstate);
53765 if (PyErr_Occurred()) SWIG_fail;
53766 }
53767 resultobj = SWIG_Py_Void();
53768 return resultobj;
53769 fail:
53770 return NULL;
53771 }
53772
53773
53774 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53775 PyObject *resultobj = 0;
53776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53777 wxRelationship result;
53778 void *argp1 = 0 ;
53779 int res1 = 0 ;
53780 PyObject *swig_obj[1] ;
53781
53782 if (!args) SWIG_fail;
53783 swig_obj[0] = args;
53784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53785 if (!SWIG_IsOK(res1)) {
53786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53787 }
53788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53789 {
53790 PyThreadState* __tstate = wxPyBeginAllowThreads();
53791 result = (wxRelationship)(arg1)->GetRelationship();
53792 wxPyEndAllowThreads(__tstate);
53793 if (PyErr_Occurred()) SWIG_fail;
53794 }
53795 resultobj = SWIG_From_int(static_cast< int >(result));
53796 return resultobj;
53797 fail:
53798 return NULL;
53799 }
53800
53801
53802 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53803 PyObject *resultobj = 0;
53804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53805 wxRelationship arg2 ;
53806 void *argp1 = 0 ;
53807 int res1 = 0 ;
53808 int val2 ;
53809 int ecode2 = 0 ;
53810 PyObject * obj0 = 0 ;
53811 PyObject * obj1 = 0 ;
53812 char * kwnames[] = {
53813 (char *) "self",(char *) "r", NULL
53814 };
53815
53816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53818 if (!SWIG_IsOK(res1)) {
53819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53820 }
53821 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53822 ecode2 = SWIG_AsVal_int(obj1, &val2);
53823 if (!SWIG_IsOK(ecode2)) {
53824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53825 }
53826 arg2 = static_cast< wxRelationship >(val2);
53827 {
53828 PyThreadState* __tstate = wxPyBeginAllowThreads();
53829 (arg1)->SetRelationship(arg2);
53830 wxPyEndAllowThreads(__tstate);
53831 if (PyErr_Occurred()) SWIG_fail;
53832 }
53833 resultobj = SWIG_Py_Void();
53834 return resultobj;
53835 fail:
53836 return NULL;
53837 }
53838
53839
53840 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53841 PyObject *resultobj = 0;
53842 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53843 wxWindow *arg2 = (wxWindow *) 0 ;
53844 bool result;
53845 void *argp1 = 0 ;
53846 int res1 = 0 ;
53847 void *argp2 = 0 ;
53848 int res2 = 0 ;
53849 PyObject * obj0 = 0 ;
53850 PyObject * obj1 = 0 ;
53851 char * kwnames[] = {
53852 (char *) "self",(char *) "otherW", NULL
53853 };
53854
53855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53857 if (!SWIG_IsOK(res1)) {
53858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53859 }
53860 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53861 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53862 if (!SWIG_IsOK(res2)) {
53863 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53864 }
53865 arg2 = reinterpret_cast< wxWindow * >(argp2);
53866 {
53867 PyThreadState* __tstate = wxPyBeginAllowThreads();
53868 result = (bool)(arg1)->ResetIfWin(arg2);
53869 wxPyEndAllowThreads(__tstate);
53870 if (PyErr_Occurred()) SWIG_fail;
53871 }
53872 {
53873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53874 }
53875 return resultobj;
53876 fail:
53877 return NULL;
53878 }
53879
53880
53881 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53882 PyObject *resultobj = 0;
53883 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53884 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53885 wxWindow *arg3 = (wxWindow *) 0 ;
53886 bool result;
53887 void *argp1 = 0 ;
53888 int res1 = 0 ;
53889 void *argp2 = 0 ;
53890 int res2 = 0 ;
53891 void *argp3 = 0 ;
53892 int res3 = 0 ;
53893 PyObject * obj0 = 0 ;
53894 PyObject * obj1 = 0 ;
53895 PyObject * obj2 = 0 ;
53896 char * kwnames[] = {
53897 (char *) "self",(char *) "constraints",(char *) "win", NULL
53898 };
53899
53900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53902 if (!SWIG_IsOK(res1)) {
53903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53904 }
53905 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53907 if (!SWIG_IsOK(res2)) {
53908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53909 }
53910 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53911 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53912 if (!SWIG_IsOK(res3)) {
53913 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53914 }
53915 arg3 = reinterpret_cast< wxWindow * >(argp3);
53916 {
53917 PyThreadState* __tstate = wxPyBeginAllowThreads();
53918 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53919 wxPyEndAllowThreads(__tstate);
53920 if (PyErr_Occurred()) SWIG_fail;
53921 }
53922 {
53923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53924 }
53925 return resultobj;
53926 fail:
53927 return NULL;
53928 }
53929
53930
53931 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53932 PyObject *resultobj = 0;
53933 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53934 wxEdge arg2 ;
53935 wxWindow *arg3 = (wxWindow *) 0 ;
53936 wxWindow *arg4 = (wxWindow *) 0 ;
53937 int result;
53938 void *argp1 = 0 ;
53939 int res1 = 0 ;
53940 int val2 ;
53941 int ecode2 = 0 ;
53942 void *argp3 = 0 ;
53943 int res3 = 0 ;
53944 void *argp4 = 0 ;
53945 int res4 = 0 ;
53946 PyObject * obj0 = 0 ;
53947 PyObject * obj1 = 0 ;
53948 PyObject * obj2 = 0 ;
53949 PyObject * obj3 = 0 ;
53950 char * kwnames[] = {
53951 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53952 };
53953
53954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53956 if (!SWIG_IsOK(res1)) {
53957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53958 }
53959 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53960 ecode2 = SWIG_AsVal_int(obj1, &val2);
53961 if (!SWIG_IsOK(ecode2)) {
53962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53963 }
53964 arg2 = static_cast< wxEdge >(val2);
53965 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53966 if (!SWIG_IsOK(res3)) {
53967 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53968 }
53969 arg3 = reinterpret_cast< wxWindow * >(argp3);
53970 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53971 if (!SWIG_IsOK(res4)) {
53972 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53973 }
53974 arg4 = reinterpret_cast< wxWindow * >(argp4);
53975 {
53976 PyThreadState* __tstate = wxPyBeginAllowThreads();
53977 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53978 wxPyEndAllowThreads(__tstate);
53979 if (PyErr_Occurred()) SWIG_fail;
53980 }
53981 resultobj = SWIG_From_int(static_cast< int >(result));
53982 return resultobj;
53983 fail:
53984 return NULL;
53985 }
53986
53987
53988 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53989 PyObject *obj;
53990 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53991 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53992 return SWIG_Py_Void();
53993 }
53994
53995 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53996 PyObject *resultobj = 0;
53997 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53998 wxIndividualLayoutConstraint *result = 0 ;
53999 void *argp1 = 0 ;
54000 int res1 = 0 ;
54001 PyObject *swig_obj[1] ;
54002
54003 if (!args) SWIG_fail;
54004 swig_obj[0] = args;
54005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54006 if (!SWIG_IsOK(res1)) {
54007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54008 }
54009 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54010 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
54011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54012 return resultobj;
54013 fail:
54014 return NULL;
54015 }
54016
54017
54018 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54019 PyObject *resultobj = 0;
54020 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54021 wxIndividualLayoutConstraint *result = 0 ;
54022 void *argp1 = 0 ;
54023 int res1 = 0 ;
54024 PyObject *swig_obj[1] ;
54025
54026 if (!args) SWIG_fail;
54027 swig_obj[0] = args;
54028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54029 if (!SWIG_IsOK(res1)) {
54030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54031 }
54032 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54033 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54035 return resultobj;
54036 fail:
54037 return NULL;
54038 }
54039
54040
54041 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54042 PyObject *resultobj = 0;
54043 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54044 wxIndividualLayoutConstraint *result = 0 ;
54045 void *argp1 = 0 ;
54046 int res1 = 0 ;
54047 PyObject *swig_obj[1] ;
54048
54049 if (!args) SWIG_fail;
54050 swig_obj[0] = args;
54051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54052 if (!SWIG_IsOK(res1)) {
54053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54054 }
54055 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54056 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54058 return resultobj;
54059 fail:
54060 return NULL;
54061 }
54062
54063
54064 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54065 PyObject *resultobj = 0;
54066 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54067 wxIndividualLayoutConstraint *result = 0 ;
54068 void *argp1 = 0 ;
54069 int res1 = 0 ;
54070 PyObject *swig_obj[1] ;
54071
54072 if (!args) SWIG_fail;
54073 swig_obj[0] = args;
54074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54075 if (!SWIG_IsOK(res1)) {
54076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54077 }
54078 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54079 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54081 return resultobj;
54082 fail:
54083 return NULL;
54084 }
54085
54086
54087 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54088 PyObject *resultobj = 0;
54089 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54090 wxIndividualLayoutConstraint *result = 0 ;
54091 void *argp1 = 0 ;
54092 int res1 = 0 ;
54093 PyObject *swig_obj[1] ;
54094
54095 if (!args) SWIG_fail;
54096 swig_obj[0] = args;
54097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54098 if (!SWIG_IsOK(res1)) {
54099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54100 }
54101 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54102 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54104 return resultobj;
54105 fail:
54106 return NULL;
54107 }
54108
54109
54110 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54111 PyObject *resultobj = 0;
54112 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54113 wxIndividualLayoutConstraint *result = 0 ;
54114 void *argp1 = 0 ;
54115 int res1 = 0 ;
54116 PyObject *swig_obj[1] ;
54117
54118 if (!args) SWIG_fail;
54119 swig_obj[0] = args;
54120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54121 if (!SWIG_IsOK(res1)) {
54122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54123 }
54124 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54125 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54127 return resultobj;
54128 fail:
54129 return NULL;
54130 }
54131
54132
54133 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54134 PyObject *resultobj = 0;
54135 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54136 wxIndividualLayoutConstraint *result = 0 ;
54137 void *argp1 = 0 ;
54138 int res1 = 0 ;
54139 PyObject *swig_obj[1] ;
54140
54141 if (!args) SWIG_fail;
54142 swig_obj[0] = args;
54143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54144 if (!SWIG_IsOK(res1)) {
54145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54146 }
54147 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54148 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54150 return resultobj;
54151 fail:
54152 return NULL;
54153 }
54154
54155
54156 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54157 PyObject *resultobj = 0;
54158 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54159 wxIndividualLayoutConstraint *result = 0 ;
54160 void *argp1 = 0 ;
54161 int res1 = 0 ;
54162 PyObject *swig_obj[1] ;
54163
54164 if (!args) SWIG_fail;
54165 swig_obj[0] = args;
54166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54167 if (!SWIG_IsOK(res1)) {
54168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54169 }
54170 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54171 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54173 return resultobj;
54174 fail:
54175 return NULL;
54176 }
54177
54178
54179 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54180 PyObject *resultobj = 0;
54181 wxLayoutConstraints *result = 0 ;
54182
54183 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54184 {
54185 PyThreadState* __tstate = wxPyBeginAllowThreads();
54186 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54187 wxPyEndAllowThreads(__tstate);
54188 if (PyErr_Occurred()) SWIG_fail;
54189 }
54190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54191 return resultobj;
54192 fail:
54193 return NULL;
54194 }
54195
54196
54197 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54198 PyObject *resultobj = 0;
54199 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54200 void *argp1 = 0 ;
54201 int res1 = 0 ;
54202 PyObject *swig_obj[1] ;
54203
54204 if (!args) SWIG_fail;
54205 swig_obj[0] = args;
54206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54207 if (!SWIG_IsOK(res1)) {
54208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54209 }
54210 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54211 {
54212 PyThreadState* __tstate = wxPyBeginAllowThreads();
54213 delete arg1;
54214
54215 wxPyEndAllowThreads(__tstate);
54216 if (PyErr_Occurred()) SWIG_fail;
54217 }
54218 resultobj = SWIG_Py_Void();
54219 return resultobj;
54220 fail:
54221 return NULL;
54222 }
54223
54224
54225 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54226 PyObject *resultobj = 0;
54227 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54228 wxWindow *arg2 = (wxWindow *) 0 ;
54229 int *arg3 = (int *) 0 ;
54230 bool result;
54231 void *argp1 = 0 ;
54232 int res1 = 0 ;
54233 void *argp2 = 0 ;
54234 int res2 = 0 ;
54235 int temp3 ;
54236 int res3 = SWIG_TMPOBJ ;
54237 PyObject * obj0 = 0 ;
54238 PyObject * obj1 = 0 ;
54239 char * kwnames[] = {
54240 (char *) "self",(char *) "win", NULL
54241 };
54242
54243 arg3 = &temp3;
54244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54246 if (!SWIG_IsOK(res1)) {
54247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54248 }
54249 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54250 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54251 if (!SWIG_IsOK(res2)) {
54252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54253 }
54254 arg2 = reinterpret_cast< wxWindow * >(argp2);
54255 {
54256 PyThreadState* __tstate = wxPyBeginAllowThreads();
54257 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54258 wxPyEndAllowThreads(__tstate);
54259 if (PyErr_Occurred()) SWIG_fail;
54260 }
54261 {
54262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54263 }
54264 if (SWIG_IsTmpObj(res3)) {
54265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54266 } else {
54267 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54269 }
54270 return resultobj;
54271 fail:
54272 return NULL;
54273 }
54274
54275
54276 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54277 PyObject *resultobj = 0;
54278 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54279 bool result;
54280 void *argp1 = 0 ;
54281 int res1 = 0 ;
54282 PyObject *swig_obj[1] ;
54283
54284 if (!args) SWIG_fail;
54285 swig_obj[0] = args;
54286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54287 if (!SWIG_IsOK(res1)) {
54288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54289 }
54290 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54291 {
54292 PyThreadState* __tstate = wxPyBeginAllowThreads();
54293 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54294 wxPyEndAllowThreads(__tstate);
54295 if (PyErr_Occurred()) SWIG_fail;
54296 }
54297 {
54298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54299 }
54300 return resultobj;
54301 fail:
54302 return NULL;
54303 }
54304
54305
54306 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54307 PyObject *obj;
54308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54309 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54310 return SWIG_Py_Void();
54311 }
54312
54313 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54314 return SWIG_Python_InitShadowInstance(args);
54315 }
54316
54317 static PyMethodDef SwigMethods[] = {
54318 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54319 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54320 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54321 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54322 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54323 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54324 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54325 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54326 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54328 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54341 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54342 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54343 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54345 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54346 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54347 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54348 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54349 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54350 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54351 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54353 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54359 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54360 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54361 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54362 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54363 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54364 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54365 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54367 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54369 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54375 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54376 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54377 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54382 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54383 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54385 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54387 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54389 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54391 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54393 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54395 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54396 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54398 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54400 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54402 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54404 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54405 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54406 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54407 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54409 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54427 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54428 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54429 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54430 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54431 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54432 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54433 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54434 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54436 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54437 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54438 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54442 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54443 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54444 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54445 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54446 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54447 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54451 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54454 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54461 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54462 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54463 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54464 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54466 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54467 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54468 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54470 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54471 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54472 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54473 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54475 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54478 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54479 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54480 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54481 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54482 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54483 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54486 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54487 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54488 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54490 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54491 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54493 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54494 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54495 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54496 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54497 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54498 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54499 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54500 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54501 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54502 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54503 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54504 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54509 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54513 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54515 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54516 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54517 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54518 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54520 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54523 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54526 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54529 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54530 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54531 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54534 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54535 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54536 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54540 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54541 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54542 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54543 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54546 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54551 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54552 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54553 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54554 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54555 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54556 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54557 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54559 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54563 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54564 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54565 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54567 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54568 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54569 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54571 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54572 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54575 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54576 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54578 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54579 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54580 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54581 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54582 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54583 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54584 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54585 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54587 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54588 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54589 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54590 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54591 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54592 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54593 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54594 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54596 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54601 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54605 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54622 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54623 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54638 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54639 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54640 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54641 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54644 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54646 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54648 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54650 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54652 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54655 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54656 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54657 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54658 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54660 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54662 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54665 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54675 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54677 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54678 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54682 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54684 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54685 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54687 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54688 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54689 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54690 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54691 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54692 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54693 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54694 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54695 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54696 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54697 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54698 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54699 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54700 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54701 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54702 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54703 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54704 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54705 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54706 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54707 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54708 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54709 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54710 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54711 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54712 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54713 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54714 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54715 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54716 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54717 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54718 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54719 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54721 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54722 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54723 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54724 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54727 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54731 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54733 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54734 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54737 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54738 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54739 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54740 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54741 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54742 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54743 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54744 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54746 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54748 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54750 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54752 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54753 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54754 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54756 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54757 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54759 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54760 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54761 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54763 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54764 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54765 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54767 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54769 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54770 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54771 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54773 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54775 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54776 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54778 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54779 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54780 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54782 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54783 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54784 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54785 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54786 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54788 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54789 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54792 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54793 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54795 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54796 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54799 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54800 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54802 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54808 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54809 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54810 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54811 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54812 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54813 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54814 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54815 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54816 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54817 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54818 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54819 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54820 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54821 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54822 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54823 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54824 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54825 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54826 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54827 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54828 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54829 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54830 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54831 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54833 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54834 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54835 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54836 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54837 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54838 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54839 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54840 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54841 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54842 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54843 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54844 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54845 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54846 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54847 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54848 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54849 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54850 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54851 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54852 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54853 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54854 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54855 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54856 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54857 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54858 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54859 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54860 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54861 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54862 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54863 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54864 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54866 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54867 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54869 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54870 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54871 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54872 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54874 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54875 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54876 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54877 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54878 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54879 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54880 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54881 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54882 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54884 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54885 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54886 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54887 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54888 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54889 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54890 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54891 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54892 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54893 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54894 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54895 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54896 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54897 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54898 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54899 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54900 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54901 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54902 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54903 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54904 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54905 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54906 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54907 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54908 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54909 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54910 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54911 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54913 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54914 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54917 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54918 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54919 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54920 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54921 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54922 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54924 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54925 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54928 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54929 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54931 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54932 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54934 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54935 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54937 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54938 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54939 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54941 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54943 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54944 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54946 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54947 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54948 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54950 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54951 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54952 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54954 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54955 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54957 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54958 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54959 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54960 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54961 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54964 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54966 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54968 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54969 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54970 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54973 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54974 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54975 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54977 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54978 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54979 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54981 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54982 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54983 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54984 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54985 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54986 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54988 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54989 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54990 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54991 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54992 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54993 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54994 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54995 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
55001 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
55003 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
55005 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
55006 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
55007 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
55008 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
55009 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
55010 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
55012 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
55013 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
55014 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
55016 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
55017 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
55018 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
55019 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
55020 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
55023 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
55024 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
55025 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
55028 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
55029 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
55030 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55031 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55032 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55034 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55036 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55039 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55041 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55042 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55044 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55045 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55046 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55048 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55049 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55050 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55052 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55054 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55055 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55056 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55058 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55060 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55062 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55063 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55065 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55066 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55068 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55070 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55071 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55072 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55074 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55076 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55077 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55078 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55079 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55080 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55082 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55083 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55084 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55085 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55087 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55089 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55091 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55093 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55094 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55096 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55097 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55098 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55099 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55100 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55101 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55102 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55103 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55104 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55106 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55108 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55110 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55112 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55114 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55116 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55117 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55118 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55119 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55120 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55121 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55127 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55128 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55129 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55130 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55131 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55132 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55133 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55134 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55136 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55138 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55139 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55141 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55142 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55143 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55144 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55146 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55147 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55148 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55149 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55151 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55152 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55154 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55155 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55156 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55158 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55161 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55162 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55163 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55164 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55165 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55167 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55168 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55170 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55171 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55172 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55173 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55175 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55176 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55177 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55178 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55179 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55180 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55181 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55182 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55183 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55184 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55186 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55189 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55190 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55191 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55193 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55195 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55197 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55199 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55200 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55201 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55202 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55203 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55208 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55209 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55210 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55213 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55214 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55218 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55219 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55220 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55221 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55222 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55223 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55224 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55225 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55226 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55227 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55228 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55229 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55230 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55231 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55232 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55233 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55234 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55235 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55236 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55237 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55238 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55239 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55241 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55242 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55243 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55244 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55245 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55247 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55248 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55249 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55250 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55251 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55252 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55253 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55254 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55255 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55256 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55258 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55260 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55261 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55262 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55263 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55265 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55267 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55269 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55272 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55273 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55274 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55275 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55276 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55277 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55278 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55279 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55281 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55282 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55283 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55284 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55289 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55291 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55294 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55296 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55297 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55298 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55299 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55300 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55301 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55303 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55305 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55306 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55307 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55308 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55313 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55314 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55315 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55316 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55317 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55318 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55319 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55320 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55321 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55322 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55323 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55325 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55326 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55327 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55328 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55329 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55330 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55331 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55334 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55337 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55338 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55339 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55340 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55342 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55343 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55344 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55345 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55346 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55348 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55350 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55351 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55352 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55354 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55355 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55356 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55357 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55358 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55359 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55361 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55362 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55363 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55364 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55365 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55366 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55368 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
55369 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55370 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55371 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55373 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55374 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55375 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55376 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55377 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55379 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55380 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55381 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55382 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55384 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55385 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55386 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55388 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55389 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55390 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55391 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55392 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55394 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55395 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55396 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55397 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55398 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55399 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55400 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55401 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55402 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55403 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55404 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55405 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55407 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55408 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55413 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55414 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55415 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55416 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55417 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55418 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55419 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55421 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55422 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55423 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55424 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55425 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55427 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55428 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55431 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55434 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55435 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55439 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55442 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55446 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55448 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55449 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55450 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55451 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55452 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55453 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55454 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55455 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55457 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55458 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55460 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55461 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55462 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55466 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55471 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55473 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55475 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55476 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55477 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55478 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55479 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55480 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55481 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55482 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55483 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55484 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55485 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55486 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55488 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55489 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55491 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55492 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55493 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55495 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55496 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55499 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55500 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55502 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55503 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55505 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55506 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55508 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55509 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55510 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55511 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55512 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55513 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55514 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55515 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55516 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55518 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55519 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55521 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55522 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55523 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55524 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55525 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55526 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55528 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55529 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55530 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55531 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55532 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55533 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55534 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55535 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55536 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55537 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55538 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55539 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55540 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55541 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55542 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55543 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55544 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55545 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55547 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55548 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55549 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55550 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55551 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55552 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55553 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55554 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55555 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55556 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55557 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55558 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55559 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55560 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55561 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55562 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55563 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55564 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55565 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55566 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55567 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55568 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55569 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55570 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55571 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55574 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55575 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55576 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55577 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55578 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55579 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55580 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55582 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55583 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55585 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55586 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55587 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55588 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55589 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55590 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55591 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55592 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55593 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55594 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55595 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55596 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55597 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55598 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55599 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55600 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55602 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55603 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55604 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55605 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55606 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55607 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55608 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55609 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55610 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55611 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55612 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55614 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55615 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55616 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55617 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55618 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55619 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55621 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55622 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55623 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55624 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55625 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55626 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55627 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55628 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55629 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55630 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55631 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55632 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55633 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55634 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55635 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55636 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55639 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55640 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55641 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55642 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55643 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55644 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55645 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55646 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55647 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55648 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55649 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55650 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55651 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55652 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55653 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55654 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55655 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55656 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55657 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55658 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55659 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55660 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55661 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55662 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55663 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55664 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55665 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55666 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55667 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55668 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55669 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55670 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55671 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55672 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55673 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55674 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55675 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55676 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55677 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55678 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55679 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55680 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55681 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55682 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55683 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55684 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55685 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55686 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55687 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55688 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55689 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55690 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55691 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55692 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55693 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55694 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55695 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55696 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55697 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55698 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55699 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55700 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55701 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55702 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55703 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55704 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55705 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55706 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55707 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55708 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55709 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55710 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55711 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55712 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55713 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55714 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55715 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55716 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55717 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55718 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55719 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55720 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55721 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55722 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55723 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55724 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55725 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55726 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55727 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55728 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55729 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55730 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55731 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55732 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55733 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55734 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55735 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55736 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55737 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55738 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55739 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55740 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55741 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55742 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55743 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55744 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55745 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55746 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55747 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55748 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55750 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55751 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55752 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55753 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55754 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55756 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55757 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55758 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55759 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55760 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55761 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55762 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55763 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55764 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55765 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55766 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55767 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55768 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55769 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55770 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55771 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55772 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55773 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55774 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55775 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55776 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55777 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55778 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55779 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55780 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55781 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55782 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55783 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55784 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55785 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55786 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55787 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55788 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55789 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55790 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55791 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55792 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55793 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55794 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55795 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55796 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55797 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55798 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55799 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55800 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55801 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55802 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55803 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55804 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55805 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55806 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55807 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55808 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55809 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55810 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55811 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55812 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55813 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55814 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55815 { NULL, NULL, 0, NULL }
55816 };
55817
55818
55819 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55820
55821 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55822 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55823 }
55824 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55825 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55826 }
55827 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55828 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55829 }
55830 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55831 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55832 }
55833 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55834 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55835 }
55836 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55837 return (void *)((wxSizer *) ((wxGridSizer *) x));
55838 }
55839 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55840 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55841 }
55842 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55843 return (void *)((wxSizer *) ((wxPySizer *) x));
55844 }
55845 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55846 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55847 }
55848 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55849 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55850 }
55851 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55852 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55853 }
55854 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55855 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55856 }
55857 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55858 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55859 }
55860 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55861 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55862 }
55863 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55864 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55865 }
55866 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55867 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55868 }
55869 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55870 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55871 }
55872 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55873 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55874 }
55875 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55876 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55877 }
55878 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55879 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55880 }
55881 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55882 return (void *)((wxEvent *) ((wxPyEvent *) x));
55883 }
55884 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55885 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55886 }
55887 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55888 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55889 }
55890 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55891 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55892 }
55893 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55894 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55895 }
55896 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55897 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55898 }
55899 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55900 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55901 }
55902 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55903 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55904 }
55905 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55906 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55907 }
55908 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55909 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55910 }
55911 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55912 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55913 }
55914 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55915 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55916 }
55917 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55918 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55919 }
55920 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55921 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55922 }
55923 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55924 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55925 }
55926 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55927 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55928 }
55929 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55930 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55931 }
55932 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55933 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55934 }
55935 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55936 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55937 }
55938 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55939 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55940 }
55941 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55942 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55943 }
55944 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55945 return (void *)((wxEvent *) ((wxShowEvent *) x));
55946 }
55947 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55948 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55949 }
55950 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55951 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55952 }
55953 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55954 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55955 }
55956 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55957 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55958 }
55959 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55960 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55961 }
55962 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55963 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55964 }
55965 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55966 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55967 }
55968 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55969 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55970 }
55971 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55972 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55973 }
55974 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55975 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55976 }
55977 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55978 return (void *)((wxControl *) ((wxControlWithItems *) x));
55979 }
55980 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55981 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55982 }
55983 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55984 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55985 }
55986 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55987 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55988 }
55989 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55990 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55991 }
55992 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55993 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55994 }
55995 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55996 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55997 }
55998 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55999 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
56000 }
56001 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
56002 return (void *)((wxEvtHandler *) ((wxMenu *) x));
56003 }
56004 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
56005 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
56006 }
56007 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
56008 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
56009 }
56010 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
56011 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
56012 }
56013 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
56014 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
56015 }
56016 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
56017 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
56018 }
56019 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
56020 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56021 }
56022 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
56023 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
56024 }
56025 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
56026 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
56027 }
56028 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
56029 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
56030 }
56031 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56032 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56033 }
56034 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56035 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56036 }
56037 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56038 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56039 }
56040 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56041 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56042 }
56043 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56044 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56045 }
56046 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56047 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56048 }
56049 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56050 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56051 }
56052 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56053 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56054 }
56055 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56056 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56057 }
56058 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56059 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56060 }
56061 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56062 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56063 }
56064 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56065 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56066 }
56067 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56068 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56069 }
56070 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56071 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56072 }
56073 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56074 return (void *)((wxObject *) ((wxSizerItem *) x));
56075 }
56076 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56077 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56078 }
56079 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56080 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56081 }
56082 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56083 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56084 }
56085 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56086 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56087 }
56088 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56089 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56090 }
56091 static void *_p_wxSizerTo_p_wxObject(void *x) {
56092 return (void *)((wxObject *) ((wxSizer *) x));
56093 }
56094 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56095 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56096 }
56097 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56098 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56099 }
56100 static void *_p_wxEventTo_p_wxObject(void *x) {
56101 return (void *)((wxObject *) ((wxEvent *) x));
56102 }
56103 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56104 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56105 }
56106 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56107 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56108 }
56109 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56110 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56111 }
56112 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56113 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56114 }
56115 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56116 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56117 }
56118 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56119 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56120 }
56121 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56122 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56123 }
56124 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56125 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56126 }
56127 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56128 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56129 }
56130 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56131 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56132 }
56133 static void *_p_wxControlTo_p_wxObject(void *x) {
56134 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56135 }
56136 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56137 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56138 }
56139 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56140 return (void *)((wxObject *) ((wxFSFile *) x));
56141 }
56142 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56143 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56144 }
56145 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56146 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56147 }
56148 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56149 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56150 }
56151 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56152 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56153 }
56154 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56155 return (void *)((wxObject *) ((wxMenuItem *) x));
56156 }
56157 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56158 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56159 }
56160 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56161 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56162 }
56163 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56164 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56165 }
56166 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56167 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56168 }
56169 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56170 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56171 }
56172 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56173 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56174 }
56175 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56176 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56177 }
56178 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56179 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56180 }
56181 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56182 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56183 }
56184 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56185 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56186 }
56187 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56188 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56189 }
56190 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56191 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56192 }
56193 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56194 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56195 }
56196 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56197 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56198 }
56199 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56200 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56201 }
56202 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56203 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56204 }
56205 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56206 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56207 }
56208 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56209 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56210 }
56211 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56212 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56213 }
56214 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56215 return (void *)((wxObject *) ((wxImageHandler *) x));
56216 }
56217 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56218 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56219 }
56220 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56221 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56222 }
56223 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56224 return (void *)((wxObject *) ((wxEvtHandler *) x));
56225 }
56226 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56227 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56228 }
56229 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56230 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56231 }
56232 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56233 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56234 }
56235 static void *_p_wxImageTo_p_wxObject(void *x) {
56236 return (void *)((wxObject *) ((wxImage *) x));
56237 }
56238 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56239 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56240 }
56241 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56242 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56243 }
56244 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56245 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56246 }
56247 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56248 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56249 }
56250 static void *_p_wxWindowTo_p_wxObject(void *x) {
56251 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56252 }
56253 static void *_p_wxMenuTo_p_wxObject(void *x) {
56254 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56255 }
56256 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56257 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56258 }
56259 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56260 return (void *)((wxObject *) ((wxFileSystem *) x));
56261 }
56262 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56263 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56264 }
56265 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56266 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56267 }
56268 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56269 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56270 }
56271 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56272 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56273 }
56274 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56275 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56276 }
56277 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56278 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56279 }
56280 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56281 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56282 }
56283 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56284 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56285 }
56286 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56287 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56288 }
56289 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56290 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56291 }
56292 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56293 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56294 }
56295 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56296 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56297 }
56298 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56299 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56300 }
56301 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56302 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56303 }
56304 static void *_p_wxControlTo_p_wxWindow(void *x) {
56305 return (void *)((wxWindow *) ((wxControl *) x));
56306 }
56307 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56308 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56309 }
56310 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56311 return (void *)((wxWindow *) ((wxMenuBar *) x));
56312 }
56313 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56314 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56315 }
56316 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56317 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56318 }
56319 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56320 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56321 }
56322 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56323 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56324 }
56325 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56326 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56327 }
56328 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56329 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56330 }
56331 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56332 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56333 }
56334 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56335 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56336 }
56337 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56338 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56339 }
56340 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56341 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56342 }
56343 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56344 return (void *)((wxValidator *) ((wxPyValidator *) x));
56345 }
56346 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56348 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};
56349 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56446 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56447 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56448 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56449 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56450 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56451 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56452 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56453 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56454 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56455 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56456 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56457 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56458 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56459 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56460 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56461 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56462 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56463 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56464 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56465 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56466 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56467 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56468 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56469 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56470 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56471 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56472 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56473 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56474 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56475 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56476 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56477 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56478
56479 static swig_type_info *swig_type_initial[] = {
56480 &_swigt__p_buffer,
56481 &_swigt__p_char,
56482 &_swigt__p_form_ops_t,
56483 &_swigt__p_int,
56484 &_swigt__p_long,
56485 &_swigt__p_unsigned_char,
56486 &_swigt__p_unsigned_int,
56487 &_swigt__p_unsigned_long,
56488 &_swigt__p_wxANIHandler,
56489 &_swigt__p_wxAcceleratorEntry,
56490 &_swigt__p_wxAcceleratorTable,
56491 &_swigt__p_wxActivateEvent,
56492 &_swigt__p_wxAppTraits,
56493 &_swigt__p_wxArrayString,
56494 &_swigt__p_wxBMPHandler,
56495 &_swigt__p_wxBitmap,
56496 &_swigt__p_wxBoxSizer,
56497 &_swigt__p_wxButton,
56498 &_swigt__p_wxCURHandler,
56499 &_swigt__p_wxCaret,
56500 &_swigt__p_wxChildFocusEvent,
56501 &_swigt__p_wxClipboardTextEvent,
56502 &_swigt__p_wxCloseEvent,
56503 &_swigt__p_wxColour,
56504 &_swigt__p_wxCommandEvent,
56505 &_swigt__p_wxContextMenuEvent,
56506 &_swigt__p_wxControl,
56507 &_swigt__p_wxControlWithItems,
56508 &_swigt__p_wxCursor,
56509 &_swigt__p_wxDC,
56510 &_swigt__p_wxDateEvent,
56511 &_swigt__p_wxDateTime,
56512 &_swigt__p_wxDisplayChangedEvent,
56513 &_swigt__p_wxDropFilesEvent,
56514 &_swigt__p_wxDuplexMode,
56515 &_swigt__p_wxEraseEvent,
56516 &_swigt__p_wxEvent,
56517 &_swigt__p_wxEventLoop,
56518 &_swigt__p_wxEventLoopActivator,
56519 &_swigt__p_wxEvtHandler,
56520 &_swigt__p_wxFSFile,
56521 &_swigt__p_wxFileSystem,
56522 &_swigt__p_wxFileSystemHandler,
56523 &_swigt__p_wxFlexGridSizer,
56524 &_swigt__p_wxFocusEvent,
56525 &_swigt__p_wxFont,
56526 &_swigt__p_wxFrame,
56527 &_swigt__p_wxGBPosition,
56528 &_swigt__p_wxGBSizerItem,
56529 &_swigt__p_wxGBSpan,
56530 &_swigt__p_wxGIFHandler,
56531 &_swigt__p_wxGridBagSizer,
56532 &_swigt__p_wxGridSizer,
56533 &_swigt__p_wxHelpEvent__Origin,
56534 &_swigt__p_wxICOHandler,
56535 &_swigt__p_wxIconizeEvent,
56536 &_swigt__p_wxIdleEvent,
56537 &_swigt__p_wxImage,
56538 &_swigt__p_wxImageHandler,
56539 &_swigt__p_wxImageHistogram,
56540 &_swigt__p_wxImage_HSVValue,
56541 &_swigt__p_wxImage_RGBValue,
56542 &_swigt__p_wxIndividualLayoutConstraint,
56543 &_swigt__p_wxInitDialogEvent,
56544 &_swigt__p_wxInputStream,
56545 &_swigt__p_wxInternetFSHandler,
56546 &_swigt__p_wxItemContainer,
56547 &_swigt__p_wxJPEGHandler,
56548 &_swigt__p_wxKeyEvent,
56549 &_swigt__p_wxLayoutConstraints,
56550 &_swigt__p_wxMaximizeEvent,
56551 &_swigt__p_wxMemoryFSHandler,
56552 &_swigt__p_wxMenu,
56553 &_swigt__p_wxMenuBar,
56554 &_swigt__p_wxMenuBarBase,
56555 &_swigt__p_wxMenuEvent,
56556 &_swigt__p_wxMenuItem,
56557 &_swigt__p_wxMouseCaptureChangedEvent,
56558 &_swigt__p_wxMouseCaptureLostEvent,
56559 &_swigt__p_wxMouseEvent,
56560 &_swigt__p_wxMoveEvent,
56561 &_swigt__p_wxNavigationKeyEvent,
56562 &_swigt__p_wxNcPaintEvent,
56563 &_swigt__p_wxNotifyEvent,
56564 &_swigt__p_wxObject,
56565 &_swigt__p_wxOutputStream,
56566 &_swigt__p_wxPCXHandler,
56567 &_swigt__p_wxPNGHandler,
56568 &_swigt__p_wxPNMHandler,
56569 &_swigt__p_wxPaintEvent,
56570 &_swigt__p_wxPaletteChangedEvent,
56571 &_swigt__p_wxPaperSize,
56572 &_swigt__p_wxPoint,
56573 &_swigt__p_wxPoint2D,
56574 &_swigt__p_wxPropagateOnce,
56575 &_swigt__p_wxPropagationDisabler,
56576 &_swigt__p_wxPyApp,
56577 &_swigt__p_wxPyCommandEvent,
56578 &_swigt__p_wxPyDropTarget,
56579 &_swigt__p_wxPyEvent,
56580 &_swigt__p_wxPyFileSystemHandler,
56581 &_swigt__p_wxPyImageHandler,
56582 &_swigt__p_wxPyInputStream,
56583 &_swigt__p_wxPySizer,
56584 &_swigt__p_wxPyValidator,
56585 &_swigt__p_wxQuantize,
56586 &_swigt__p_wxQueryNewPaletteEvent,
56587 &_swigt__p_wxRealPoint,
56588 &_swigt__p_wxRect,
56589 &_swigt__p_wxRegion,
56590 &_swigt__p_wxScrollEvent,
56591 &_swigt__p_wxScrollWinEvent,
56592 &_swigt__p_wxSetCursorEvent,
56593 &_swigt__p_wxShowEvent,
56594 &_swigt__p_wxSize,
56595 &_swigt__p_wxSizeEvent,
56596 &_swigt__p_wxSizer,
56597 &_swigt__p_wxSizerItem,
56598 &_swigt__p_wxStaticBox,
56599 &_swigt__p_wxStaticBoxSizer,
56600 &_swigt__p_wxStdDialogButtonSizer,
56601 &_swigt__p_wxSysColourChangedEvent,
56602 &_swigt__p_wxTIFFHandler,
56603 &_swigt__p_wxToolTip,
56604 &_swigt__p_wxUpdateUIEvent,
56605 &_swigt__p_wxValidator,
56606 &_swigt__p_wxVisualAttributes,
56607 &_swigt__p_wxWindow,
56608 &_swigt__p_wxWindowCreateEvent,
56609 &_swigt__p_wxWindowDestroyEvent,
56610 &_swigt__p_wxXPMHandler,
56611 &_swigt__p_wxZipFSHandler,
56612 };
56613
56614 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56615 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56617 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56618 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56623 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56624 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56625 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56626 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56627 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56628 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}};
56629 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56630 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}};
56631 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56632 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}};
56633 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56634 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56635 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56636 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56638 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}};
56639 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56640 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}};
56641 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56642 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56643 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56646 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56647 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56648 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56650 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}};
56651 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56653 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}};
56654 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56656 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}};
56657 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}};
56658 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56660 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56661 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56666 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}};
56667 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56668 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}};
56669 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56672 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}};
56673 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56675 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56680 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}};
56681 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56698 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}};
56699 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56704 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56705 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56706 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56707 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56708 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56709 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56713 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56714 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56715 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56716 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56717 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56718 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56719 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56720 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56721 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56722 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56723 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56724 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56725 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56726 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56727 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56728 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56729 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56730 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}};
56731 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}};
56732 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56733 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56734 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56735 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56736 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56737 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56738 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56739 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}};
56740 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56741 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}};
56742 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56743 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56744 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56745 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56746
56747 static swig_cast_info *swig_cast_initial[] = {
56748 _swigc__p_buffer,
56749 _swigc__p_char,
56750 _swigc__p_form_ops_t,
56751 _swigc__p_int,
56752 _swigc__p_long,
56753 _swigc__p_unsigned_char,
56754 _swigc__p_unsigned_int,
56755 _swigc__p_unsigned_long,
56756 _swigc__p_wxANIHandler,
56757 _swigc__p_wxAcceleratorEntry,
56758 _swigc__p_wxAcceleratorTable,
56759 _swigc__p_wxActivateEvent,
56760 _swigc__p_wxAppTraits,
56761 _swigc__p_wxArrayString,
56762 _swigc__p_wxBMPHandler,
56763 _swigc__p_wxBitmap,
56764 _swigc__p_wxBoxSizer,
56765 _swigc__p_wxButton,
56766 _swigc__p_wxCURHandler,
56767 _swigc__p_wxCaret,
56768 _swigc__p_wxChildFocusEvent,
56769 _swigc__p_wxClipboardTextEvent,
56770 _swigc__p_wxCloseEvent,
56771 _swigc__p_wxColour,
56772 _swigc__p_wxCommandEvent,
56773 _swigc__p_wxContextMenuEvent,
56774 _swigc__p_wxControl,
56775 _swigc__p_wxControlWithItems,
56776 _swigc__p_wxCursor,
56777 _swigc__p_wxDC,
56778 _swigc__p_wxDateEvent,
56779 _swigc__p_wxDateTime,
56780 _swigc__p_wxDisplayChangedEvent,
56781 _swigc__p_wxDropFilesEvent,
56782 _swigc__p_wxDuplexMode,
56783 _swigc__p_wxEraseEvent,
56784 _swigc__p_wxEvent,
56785 _swigc__p_wxEventLoop,
56786 _swigc__p_wxEventLoopActivator,
56787 _swigc__p_wxEvtHandler,
56788 _swigc__p_wxFSFile,
56789 _swigc__p_wxFileSystem,
56790 _swigc__p_wxFileSystemHandler,
56791 _swigc__p_wxFlexGridSizer,
56792 _swigc__p_wxFocusEvent,
56793 _swigc__p_wxFont,
56794 _swigc__p_wxFrame,
56795 _swigc__p_wxGBPosition,
56796 _swigc__p_wxGBSizerItem,
56797 _swigc__p_wxGBSpan,
56798 _swigc__p_wxGIFHandler,
56799 _swigc__p_wxGridBagSizer,
56800 _swigc__p_wxGridSizer,
56801 _swigc__p_wxHelpEvent__Origin,
56802 _swigc__p_wxICOHandler,
56803 _swigc__p_wxIconizeEvent,
56804 _swigc__p_wxIdleEvent,
56805 _swigc__p_wxImage,
56806 _swigc__p_wxImageHandler,
56807 _swigc__p_wxImageHistogram,
56808 _swigc__p_wxImage_HSVValue,
56809 _swigc__p_wxImage_RGBValue,
56810 _swigc__p_wxIndividualLayoutConstraint,
56811 _swigc__p_wxInitDialogEvent,
56812 _swigc__p_wxInputStream,
56813 _swigc__p_wxInternetFSHandler,
56814 _swigc__p_wxItemContainer,
56815 _swigc__p_wxJPEGHandler,
56816 _swigc__p_wxKeyEvent,
56817 _swigc__p_wxLayoutConstraints,
56818 _swigc__p_wxMaximizeEvent,
56819 _swigc__p_wxMemoryFSHandler,
56820 _swigc__p_wxMenu,
56821 _swigc__p_wxMenuBar,
56822 _swigc__p_wxMenuBarBase,
56823 _swigc__p_wxMenuEvent,
56824 _swigc__p_wxMenuItem,
56825 _swigc__p_wxMouseCaptureChangedEvent,
56826 _swigc__p_wxMouseCaptureLostEvent,
56827 _swigc__p_wxMouseEvent,
56828 _swigc__p_wxMoveEvent,
56829 _swigc__p_wxNavigationKeyEvent,
56830 _swigc__p_wxNcPaintEvent,
56831 _swigc__p_wxNotifyEvent,
56832 _swigc__p_wxObject,
56833 _swigc__p_wxOutputStream,
56834 _swigc__p_wxPCXHandler,
56835 _swigc__p_wxPNGHandler,
56836 _swigc__p_wxPNMHandler,
56837 _swigc__p_wxPaintEvent,
56838 _swigc__p_wxPaletteChangedEvent,
56839 _swigc__p_wxPaperSize,
56840 _swigc__p_wxPoint,
56841 _swigc__p_wxPoint2D,
56842 _swigc__p_wxPropagateOnce,
56843 _swigc__p_wxPropagationDisabler,
56844 _swigc__p_wxPyApp,
56845 _swigc__p_wxPyCommandEvent,
56846 _swigc__p_wxPyDropTarget,
56847 _swigc__p_wxPyEvent,
56848 _swigc__p_wxPyFileSystemHandler,
56849 _swigc__p_wxPyImageHandler,
56850 _swigc__p_wxPyInputStream,
56851 _swigc__p_wxPySizer,
56852 _swigc__p_wxPyValidator,
56853 _swigc__p_wxQuantize,
56854 _swigc__p_wxQueryNewPaletteEvent,
56855 _swigc__p_wxRealPoint,
56856 _swigc__p_wxRect,
56857 _swigc__p_wxRegion,
56858 _swigc__p_wxScrollEvent,
56859 _swigc__p_wxScrollWinEvent,
56860 _swigc__p_wxSetCursorEvent,
56861 _swigc__p_wxShowEvent,
56862 _swigc__p_wxSize,
56863 _swigc__p_wxSizeEvent,
56864 _swigc__p_wxSizer,
56865 _swigc__p_wxSizerItem,
56866 _swigc__p_wxStaticBox,
56867 _swigc__p_wxStaticBoxSizer,
56868 _swigc__p_wxStdDialogButtonSizer,
56869 _swigc__p_wxSysColourChangedEvent,
56870 _swigc__p_wxTIFFHandler,
56871 _swigc__p_wxToolTip,
56872 _swigc__p_wxUpdateUIEvent,
56873 _swigc__p_wxValidator,
56874 _swigc__p_wxVisualAttributes,
56875 _swigc__p_wxWindow,
56876 _swigc__p_wxWindowCreateEvent,
56877 _swigc__p_wxWindowDestroyEvent,
56878 _swigc__p_wxXPMHandler,
56879 _swigc__p_wxZipFSHandler,
56880 };
56881
56882
56883 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56884
56885 static swig_const_info swig_const_table[] = {
56886 {0, 0, 0, 0.0, 0, 0}};
56887
56888 #ifdef __cplusplus
56889 }
56890 #endif
56891 /* -----------------------------------------------------------------------------
56892 * Type initialization:
56893 * This problem is tough by the requirement that no dynamic
56894 * memory is used. Also, since swig_type_info structures store pointers to
56895 * swig_cast_info structures and swig_cast_info structures store pointers back
56896 * to swig_type_info structures, we need some lookup code at initialization.
56897 * The idea is that swig generates all the structures that are needed.
56898 * The runtime then collects these partially filled structures.
56899 * The SWIG_InitializeModule function takes these initial arrays out of
56900 * swig_module, and does all the lookup, filling in the swig_module.types
56901 * array with the correct data and linking the correct swig_cast_info
56902 * structures together.
56903 *
56904 * The generated swig_type_info structures are assigned staticly to an initial
56905 * array. We just loop though that array, and handle each type individually.
56906 * First we lookup if this type has been already loaded, and if so, use the
56907 * loaded structure instead of the generated one. Then we have to fill in the
56908 * cast linked list. The cast data is initially stored in something like a
56909 * two-dimensional array. Each row corresponds to a type (there are the same
56910 * number of rows as there are in the swig_type_initial array). Each entry in
56911 * a column is one of the swig_cast_info structures for that type.
56912 * The cast_initial array is actually an array of arrays, because each row has
56913 * a variable number of columns. So to actually build the cast linked list,
56914 * we find the array of casts associated with the type, and loop through it
56915 * adding the casts to the list. The one last trick we need to do is making
56916 * sure the type pointer in the swig_cast_info struct is correct.
56917 *
56918 * First off, we lookup the cast->type name to see if it is already loaded.
56919 * There are three cases to handle:
56920 * 1) If the cast->type has already been loaded AND the type we are adding
56921 * casting info to has not been loaded (it is in this module), THEN we
56922 * replace the cast->type pointer with the type pointer that has already
56923 * been loaded.
56924 * 2) If BOTH types (the one we are adding casting info to, and the
56925 * cast->type) are loaded, THEN the cast info has already been loaded by
56926 * the previous module so we just ignore it.
56927 * 3) Finally, if cast->type has not already been loaded, then we add that
56928 * swig_cast_info to the linked list (because the cast->type) pointer will
56929 * be correct.
56930 * ----------------------------------------------------------------------------- */
56931
56932 #ifdef __cplusplus
56933 extern "C" {
56934 #if 0
56935 } /* c-mode */
56936 #endif
56937 #endif
56938
56939 #if 0
56940 #define SWIGRUNTIME_DEBUG
56941 #endif
56942
56943 SWIGRUNTIME void
56944 SWIG_InitializeModule(void *clientdata) {
56945 size_t i;
56946 swig_module_info *module_head;
56947 static int init_run = 0;
56948
56949 clientdata = clientdata;
56950
56951 if (init_run) return;
56952 init_run = 1;
56953
56954 /* Initialize the swig_module */
56955 swig_module.type_initial = swig_type_initial;
56956 swig_module.cast_initial = swig_cast_initial;
56957
56958 /* Try and load any already created modules */
56959 module_head = SWIG_GetModule(clientdata);
56960 if (module_head) {
56961 swig_module.next = module_head->next;
56962 module_head->next = &swig_module;
56963 } else {
56964 /* This is the first module loaded */
56965 swig_module.next = &swig_module;
56966 SWIG_SetModule(clientdata, &swig_module);
56967 }
56968
56969 /* Now work on filling in swig_module.types */
56970 #ifdef SWIGRUNTIME_DEBUG
56971 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56972 #endif
56973 for (i = 0; i < swig_module.size; ++i) {
56974 swig_type_info *type = 0;
56975 swig_type_info *ret;
56976 swig_cast_info *cast;
56977
56978 #ifdef SWIGRUNTIME_DEBUG
56979 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56980 #endif
56981
56982 /* if there is another module already loaded */
56983 if (swig_module.next != &swig_module) {
56984 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56985 }
56986 if (type) {
56987 /* Overwrite clientdata field */
56988 #ifdef SWIGRUNTIME_DEBUG
56989 printf("SWIG_InitializeModule: found type %s\n", type->name);
56990 #endif
56991 if (swig_module.type_initial[i]->clientdata) {
56992 type->clientdata = swig_module.type_initial[i]->clientdata;
56993 #ifdef SWIGRUNTIME_DEBUG
56994 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56995 #endif
56996 }
56997 } else {
56998 type = swig_module.type_initial[i];
56999 }
57000
57001 /* Insert casting types */
57002 cast = swig_module.cast_initial[i];
57003 while (cast->type) {
57004 /* Don't need to add information already in the list */
57005 ret = 0;
57006 #ifdef SWIGRUNTIME_DEBUG
57007 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
57008 #endif
57009 if (swig_module.next != &swig_module) {
57010 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
57011 #ifdef SWIGRUNTIME_DEBUG
57012 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
57013 #endif
57014 }
57015 if (ret) {
57016 if (type == swig_module.type_initial[i]) {
57017 #ifdef SWIGRUNTIME_DEBUG
57018 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
57019 #endif
57020 cast->type = ret;
57021 ret = 0;
57022 } else {
57023 /* Check for casting already in the list */
57024 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
57025 #ifdef SWIGRUNTIME_DEBUG
57026 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
57027 #endif
57028 if (!ocast) ret = 0;
57029 }
57030 }
57031
57032 if (!ret) {
57033 #ifdef SWIGRUNTIME_DEBUG
57034 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57035 #endif
57036 if (type->cast) {
57037 type->cast->prev = cast;
57038 cast->next = type->cast;
57039 }
57040 type->cast = cast;
57041 }
57042 cast++;
57043 }
57044 /* Set entry in modules->types array equal to the type */
57045 swig_module.types[i] = type;
57046 }
57047 swig_module.types[i] = 0;
57048
57049 #ifdef SWIGRUNTIME_DEBUG
57050 printf("**** SWIG_InitializeModule: Cast List ******\n");
57051 for (i = 0; i < swig_module.size; ++i) {
57052 int j = 0;
57053 swig_cast_info *cast = swig_module.cast_initial[i];
57054 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57055 while (cast->type) {
57056 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57057 cast++;
57058 ++j;
57059 }
57060 printf("---- Total casts: %d\n",j);
57061 }
57062 printf("**** SWIG_InitializeModule: Cast List ******\n");
57063 #endif
57064 }
57065
57066 /* This function will propagate the clientdata field of type to
57067 * any new swig_type_info structures that have been added into the list
57068 * of equivalent types. It is like calling
57069 * SWIG_TypeClientData(type, clientdata) a second time.
57070 */
57071 SWIGRUNTIME void
57072 SWIG_PropagateClientData(void) {
57073 size_t i;
57074 swig_cast_info *equiv;
57075 static int init_run = 0;
57076
57077 if (init_run) return;
57078 init_run = 1;
57079
57080 for (i = 0; i < swig_module.size; i++) {
57081 if (swig_module.types[i]->clientdata) {
57082 equiv = swig_module.types[i]->cast;
57083 while (equiv) {
57084 if (!equiv->converter) {
57085 if (equiv->type && !equiv->type->clientdata)
57086 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57087 }
57088 equiv = equiv->next;
57089 }
57090 }
57091 }
57092 }
57093
57094 #ifdef __cplusplus
57095 #if 0
57096 {
57097 /* c-mode */
57098 #endif
57099 }
57100 #endif
57101
57102
57103
57104 #ifdef __cplusplus
57105 extern "C" {
57106 #endif
57107
57108 /* Python-specific SWIG API */
57109 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57110 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57111 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57112
57113 /* -----------------------------------------------------------------------------
57114 * global variable support code.
57115 * ----------------------------------------------------------------------------- */
57116
57117 typedef struct swig_globalvar {
57118 char *name; /* Name of global variable */
57119 PyObject *(*get_attr)(void); /* Return the current value */
57120 int (*set_attr)(PyObject *); /* Set the value */
57121 struct swig_globalvar *next;
57122 } swig_globalvar;
57123
57124 typedef struct swig_varlinkobject {
57125 PyObject_HEAD
57126 swig_globalvar *vars;
57127 } swig_varlinkobject;
57128
57129 SWIGINTERN PyObject *
57130 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57131 return PyString_FromString("<Swig global variables>");
57132 }
57133
57134 SWIGINTERN PyObject *
57135 swig_varlink_str(swig_varlinkobject *v) {
57136 PyObject *str = PyString_FromString("(");
57137 swig_globalvar *var;
57138 for (var = v->vars; var; var=var->next) {
57139 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57140 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57141 }
57142 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57143 return str;
57144 }
57145
57146 SWIGINTERN int
57147 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57148 PyObject *str = swig_varlink_str(v);
57149 fprintf(fp,"Swig global variables ");
57150 fprintf(fp,"%s\n", PyString_AsString(str));
57151 Py_DECREF(str);
57152 return 0;
57153 }
57154
57155 SWIGINTERN void
57156 swig_varlink_dealloc(swig_varlinkobject *v) {
57157 swig_globalvar *var = v->vars;
57158 while (var) {
57159 swig_globalvar *n = var->next;
57160 free(var->name);
57161 free(var);
57162 var = n;
57163 }
57164 }
57165
57166 SWIGINTERN PyObject *
57167 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57168 PyObject *res = NULL;
57169 swig_globalvar *var = v->vars;
57170 while (var) {
57171 if (strcmp(var->name,n) == 0) {
57172 res = (*var->get_attr)();
57173 break;
57174 }
57175 var = var->next;
57176 }
57177 if (res == NULL && !PyErr_Occurred()) {
57178 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57179 }
57180 return res;
57181 }
57182
57183 SWIGINTERN int
57184 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57185 int res = 1;
57186 swig_globalvar *var = v->vars;
57187 while (var) {
57188 if (strcmp(var->name,n) == 0) {
57189 res = (*var->set_attr)(p);
57190 break;
57191 }
57192 var = var->next;
57193 }
57194 if (res == 1 && !PyErr_Occurred()) {
57195 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57196 }
57197 return res;
57198 }
57199
57200 SWIGINTERN PyTypeObject*
57201 swig_varlink_type(void) {
57202 static char varlink__doc__[] = "Swig var link object";
57203 static PyTypeObject varlink_type;
57204 static int type_init = 0;
57205 if (!type_init) {
57206 const PyTypeObject tmp
57207 = {
57208 PyObject_HEAD_INIT(NULL)
57209 0, /* Number of items in variable part (ob_size) */
57210 (char *)"swigvarlink", /* Type name (tp_name) */
57211 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57212 0, /* Itemsize (tp_itemsize) */
57213 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57214 (printfunc) swig_varlink_print, /* Print (tp_print) */
57215 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57216 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57217 0, /* tp_compare */
57218 (reprfunc) swig_varlink_repr, /* tp_repr */
57219 0, /* tp_as_number */
57220 0, /* tp_as_sequence */
57221 0, /* tp_as_mapping */
57222 0, /* tp_hash */
57223 0, /* tp_call */
57224 (reprfunc)swig_varlink_str, /* tp_str */
57225 0, /* tp_getattro */
57226 0, /* tp_setattro */
57227 0, /* tp_as_buffer */
57228 0, /* tp_flags */
57229 varlink__doc__, /* tp_doc */
57230 0, /* tp_traverse */
57231 0, /* tp_clear */
57232 0, /* tp_richcompare */
57233 0, /* tp_weaklistoffset */
57234 #if PY_VERSION_HEX >= 0x02020000
57235 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57236 #endif
57237 #if PY_VERSION_HEX >= 0x02030000
57238 0, /* tp_del */
57239 #endif
57240 #ifdef COUNT_ALLOCS
57241 0,0,0,0 /* tp_alloc -> tp_next */
57242 #endif
57243 };
57244 varlink_type = tmp;
57245 varlink_type.ob_type = &PyType_Type;
57246 type_init = 1;
57247 }
57248 return &varlink_type;
57249 }
57250
57251 /* Create a variable linking object for use later */
57252 SWIGINTERN PyObject *
57253 SWIG_Python_newvarlink(void) {
57254 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57255 if (result) {
57256 result->vars = 0;
57257 }
57258 return ((PyObject*) result);
57259 }
57260
57261 SWIGINTERN void
57262 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57263 swig_varlinkobject *v = (swig_varlinkobject *) p;
57264 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57265 if (gv) {
57266 size_t size = strlen(name)+1;
57267 gv->name = (char *)malloc(size);
57268 if (gv->name) {
57269 strncpy(gv->name,name,size);
57270 gv->get_attr = get_attr;
57271 gv->set_attr = set_attr;
57272 gv->next = v->vars;
57273 }
57274 }
57275 v->vars = gv;
57276 }
57277
57278 SWIGINTERN PyObject *
57279 SWIG_globals() {
57280 static PyObject *_SWIG_globals = 0;
57281 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57282 return _SWIG_globals;
57283 }
57284
57285 /* -----------------------------------------------------------------------------
57286 * constants/methods manipulation
57287 * ----------------------------------------------------------------------------- */
57288
57289 /* Install Constants */
57290 SWIGINTERN void
57291 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57292 PyObject *obj = 0;
57293 size_t i;
57294 for (i = 0; constants[i].type; ++i) {
57295 switch(constants[i].type) {
57296 case SWIG_PY_POINTER:
57297 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57298 break;
57299 case SWIG_PY_BINARY:
57300 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57301 break;
57302 default:
57303 obj = 0;
57304 break;
57305 }
57306 if (obj) {
57307 PyDict_SetItemString(d, constants[i].name, obj);
57308 Py_DECREF(obj);
57309 }
57310 }
57311 }
57312
57313 /* -----------------------------------------------------------------------------*/
57314 /* Fix SwigMethods to carry the callback ptrs when needed */
57315 /* -----------------------------------------------------------------------------*/
57316
57317 SWIGINTERN void
57318 SWIG_Python_FixMethods(PyMethodDef *methods,
57319 swig_const_info *const_table,
57320 swig_type_info **types,
57321 swig_type_info **types_initial) {
57322 size_t i;
57323 for (i = 0; methods[i].ml_name; ++i) {
57324 const char *c = methods[i].ml_doc;
57325 if (c && (c = strstr(c, "swig_ptr: "))) {
57326 int j;
57327 swig_const_info *ci = 0;
57328 const char *name = c + 10;
57329 for (j = 0; const_table[j].type; ++j) {
57330 if (strncmp(const_table[j].name, name,
57331 strlen(const_table[j].name)) == 0) {
57332 ci = &(const_table[j]);
57333 break;
57334 }
57335 }
57336 if (ci) {
57337 size_t shift = (ci->ptype) - types;
57338 swig_type_info *ty = types_initial[shift];
57339 size_t ldoc = (c - methods[i].ml_doc);
57340 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57341 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57342 if (ndoc) {
57343 char *buff = ndoc;
57344 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57345 if (ptr) {
57346 strncpy(buff, methods[i].ml_doc, ldoc);
57347 buff += ldoc;
57348 strncpy(buff, "swig_ptr: ", 10);
57349 buff += 10;
57350 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57351 methods[i].ml_doc = ndoc;
57352 }
57353 }
57354 }
57355 }
57356 }
57357 }
57358
57359 #ifdef __cplusplus
57360 }
57361 #endif
57362
57363 /* -----------------------------------------------------------------------------*
57364 * Partial Init method
57365 * -----------------------------------------------------------------------------*/
57366
57367 #ifdef __cplusplus
57368 extern "C"
57369 #endif
57370 SWIGEXPORT void SWIG_init(void) {
57371 PyObject *m, *d;
57372
57373 /* Fix SwigMethods to carry the callback ptrs when needed */
57374 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57375
57376 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57377 d = PyModule_GetDict(m);
57378
57379 SWIG_InitializeModule(0);
57380 SWIG_InstallConstants(d,swig_const_table);
57381
57382
57383
57384 #ifndef wxPyUSE_EXPORT
57385 // Make our API structure a CObject so other modules can import it
57386 // from this module.
57387 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57388 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57389 Py_XDECREF(cobj);
57390 #endif
57391
57392 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57393 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57394 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57395 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57396 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57397 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57398 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57399 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57400 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57401 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57402 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57403 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57404 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57405 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57406 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57407 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57408 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57409 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57410 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57411 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57412 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57413 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57414 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57415 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57416 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57417 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57418 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57419 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57420 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57421 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57422 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57423 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57424 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57425 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57426 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57427 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57428 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57429 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57430 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57431 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57432 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57433 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57434 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57435 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57436 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57437 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57438 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57439 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57440 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57441 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57442 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57443 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57444 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57445 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57446 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57447 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57448 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57449 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57450 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57451 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57452 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57453 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57454 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57455 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57456 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57457 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57458 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57459 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57460 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57461 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57462 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57463 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57464 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57465 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57466 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57467 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57468 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57469 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57470 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57471 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57472 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57473 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57474 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57475 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57476 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57477 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57478 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57479 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57480 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57481 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57482 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57483 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57484 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57485 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57486 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57487 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57488 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57489 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57490 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57491 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57492 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57493 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57494 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57495 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57496 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57497 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57498 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57499 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57500 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57501 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57502 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57503 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57504 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57505 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57506 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57507 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57508 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57509 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57510 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57511 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57512 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57513 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57514 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57515 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57516 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57517 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57518 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57519 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57520 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57521 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57522 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57523 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57524 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57525 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57526 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57527 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57528 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57529 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57530 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57531 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57532 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57533 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57534 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57535 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57536 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57537 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57538 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57539 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57540 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57541 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57542 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57543 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57544 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57545 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57546 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57547 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57548 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57549 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57550 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57551 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57552 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57553 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57554 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57555 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57556 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57557 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57558 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57559 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57560 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57561 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57562 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57563 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57564 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57565 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57566 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57567 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57568 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57569 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57570 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57571 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57572 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57573 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57574 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57575 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57576 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57577 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57578 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57579 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57580 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57581 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57582 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57583 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57584 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57585 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57586 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57587 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57588 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57589 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57590 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57591 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57592 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57593 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57594 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57595 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57596 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57597 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57598 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57599 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57600 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57601 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57602 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57603 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57604 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57605 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57606 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57607 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57608 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57609 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57610 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57611 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57612 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57613 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57614 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57615 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57616 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57617 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57618 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57619 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57620 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57621 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57622 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57623 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57624 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57625 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57626 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57627 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57628 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57629 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57630 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57631 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57632 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57633 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57634 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57635 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57636 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57637 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57638 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57639 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57640 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57641 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57642 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57643 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57644 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57645 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57646 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57647 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57648 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57649 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57650 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57651 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57652 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57653 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57654 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57655 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57656 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57657 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57658 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57659 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57660 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57661 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57662 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57663 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57664 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57665 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57666 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57667 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57668 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57669 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57670 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57671 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57672 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57673 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57674 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57675 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57676 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57677 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57678 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57679 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57680 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57681 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57682 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57683 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57684 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57685 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57686 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57687 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57688 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57689 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57690 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57691 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57692 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57693 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57694 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57695 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57696 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57697 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57698 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57699 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57700 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57701 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57702 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57703 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57704 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57705 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57706 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57707 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57708 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57709 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57710 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57711 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57712 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57713 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57714 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57715 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57716 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57717 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57718 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57719 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57720 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57721 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57722 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57723 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57724 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57725 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57726 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57727 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57728 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57729 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57730 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57731 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57732 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57733 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57734 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57735 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57736 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57737 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57738 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57739 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57740 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57741 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57742 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57743 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57744 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57745 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57746 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57747 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57748 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57749 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57750 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57751 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57752 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57753 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57754 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57755 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57756 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57757 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57758 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57759 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57760 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57761 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57762 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57763 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57764 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57765 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57766 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57767 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57768 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57769 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57770 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57771 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57772 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57773 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57774 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57775 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57776 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57777 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57778 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57779 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57780 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57781 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57782 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57783 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57784 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57785 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57786 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57787 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57788 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57789 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57790 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57791 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57792 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57793 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57794 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57795 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57796 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57797 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57798 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57799 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57800 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57801 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57802 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57803 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57804 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57805 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57806 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57807 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57808 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57809 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57810 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57811 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57812 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57813 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57814 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57815 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57816 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57817 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57818 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57819 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57820 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57821 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57822 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57823 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57824 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57825 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57826 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57827 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57828 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57829 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57830 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57831 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57832 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57833 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57834 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57835 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57836 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57837 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57838 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57839 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57840 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57841 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57842 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57843 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57844 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57845 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57846 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57847 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57848 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57849 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57850 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57851 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57852 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57853 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57854 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57855 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57856 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57857 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57858 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57859 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57860 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57861 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57862 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57863 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57864 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57865 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57866 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57867 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57868 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57869 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57870 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57871 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57872 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57873 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57874 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57875 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57876 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57877 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57878 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57879 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57880 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57881 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57882 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57883 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57884 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57885 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57886 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57887 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57888 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57889 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57890 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57891 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57892 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57893 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57894 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57895 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57896 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57897 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57898 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57899 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57900 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57901 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57902 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57903 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57904 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57905 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57906 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57907 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57908 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57909 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57910 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57911 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57912 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57913 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57914 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57915 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57916 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57917 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57918 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57921 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57922 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57923 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57924 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57925 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57926 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57927 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57928 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57929 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57930 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57931 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57932 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57933 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57934 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57935 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57936 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57937 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57938 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57939 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57940 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57941 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57942 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57943 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57944 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57945 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57946 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57947 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57948 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57949 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57950 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57951 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57952 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57953 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57954 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57955 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57956 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57957 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57958 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57959 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57960 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57961 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57962 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57963 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57964 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57965 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57966 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57967 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57968 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57969 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57970 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57971 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57972 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57973 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57974 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57975 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57976 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57977 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57978 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57979 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57980 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57981 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57982 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57983 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57984 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57985 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57986 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57987 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57988 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57989 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57990 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57991 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57992 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57993 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57994 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57995 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57996 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57997 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57998 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57999 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
58000 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
58001 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
58002 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
58003 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
58004 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
58005 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
58006 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
58007 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
58008 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
58009 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
58010 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
58011 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
58012 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
58013 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
58014 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
58015 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
58016 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
58017 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
58018 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
58019 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
58020 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
58021 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
58022 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
58023 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
58024 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
58025 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
58026 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
58027 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
58028 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
58029 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
58030 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
58031 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58032 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58033 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58034 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58035 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58036 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58037 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58038 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58039 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58040 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58041 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58042 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58043 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58044 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58045 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58046 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58047 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58048 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58049 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58050 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58051
58052 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58053
58054
58055 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58056
58057 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58058 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58059 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58060 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58061 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58062 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58063 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58064 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58065 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58066 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58067 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58068 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58069 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58070 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58071 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58072 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58073 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58074 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58075 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58076 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58077 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58078 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58079 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58080 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58081 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58082 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58083 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58084 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58085 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58086 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58087 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58088 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58089 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58090 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58091 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58092 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58093 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58094 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58095 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58096 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58097 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58098 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58099 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58100 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58101 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58102 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58103 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58104 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58105 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58106 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58107 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58108 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58109 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58110 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58111 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58112 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58113 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58114 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58115 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58116 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58117 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58118 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58119 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58120 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58121 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58122 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58123 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58124 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58125 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58126 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58127 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58128 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58129 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58130 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58131 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58132 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58133 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58134 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58135 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58136 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58137 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58138 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58139 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58140 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58141 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58142 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58143 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58144 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58145 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58146 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58147 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58148 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58149 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58150 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58151 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58152 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58153 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58154 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58155 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58156 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58157 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58158 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58159 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58160 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58161 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58162 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58163 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58164 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58165 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58166 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58167 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58168 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58169 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58170 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58171 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58172 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58173 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58174 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58175 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58176 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58177 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58178 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58179 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58180 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58181 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58182 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58183 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58184 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58185 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58186 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58187 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58188 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58189 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58190 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58191 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58192 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58193 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58194 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58195 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58196 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58197 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58198 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58199 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58200 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58201 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58202 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58203 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58204 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58205 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58206 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58207 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58208 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58209 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58210 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58211 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58212 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58213 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58214 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58215 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58216 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58217 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58218 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58219 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58220 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58221 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58222 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58223 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58224 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58225 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58226 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58227 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58228 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58229 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58230 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58231 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58232 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58233 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58234 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58235 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58236 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58237 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58238 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58239 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58240 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58241 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58242 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58243 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58244 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58245 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58246 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58247 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58248 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58249 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58250 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58251 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58252 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58253 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58254 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58255 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58256 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58257 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58258 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58259 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58260 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58261 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58262 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58263 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58264 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58265 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58266 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58267 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58268 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58269 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58270 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58271
58272 // Initialize threading, some globals and such
58273 __wxPyPreStart(d);
58274
58275
58276 // Although these are defined in __version__ they need to be here too so
58277 // that an assert can be done to ensure that the wxPython and the wxWindows
58278 // versions match.
58279 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58280 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58281 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58282
58283 }
58284
wxWidgets (Impactor)