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


86e26ffad0a0f011be6fe2e440375065e832761f
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2957 wxSize temp, *obj = &temp;
2958 if ( other == Py_None ) return false;
2959 if ( ! wxSize_helper(other, &obj) ) {
2960 PyErr_Clear();
2961 return false;
2962 }
2963 return self->operator==(*obj);
2964 }
2965 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return true;
2968 if ( ! wxSize_helper(other, &obj)) {
2969 PyErr_Clear();
2970 return true;
2971 }
2972 return self->operator!=(*obj);
2973 }
2974 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 PyObject* tup = PyTuple_New(2);
2977 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2978 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2979 wxPyEndBlockThreads(blocked);
2980 return tup;
2981 }
2982
2983 SWIGINTERN int
2984 SWIG_AsVal_double (PyObject *obj, double* val)
2985 {
2986 if (PyNumber_Check(obj)) {
2987 if (val) *val = PyFloat_AsDouble(obj);
2988 return SWIG_OK;
2989 }
2990 return SWIG_TypeError;
2991 }
2992
2993
2994 #define SWIG_From_double PyFloat_FromDouble
2995
2996 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
2997 wxRealPoint temp, *obj = &temp;
2998 if ( other == Py_None ) return false;
2999 if ( ! wxRealPoint_helper(other, &obj) ) {
3000 PyErr_Clear();
3001 return false;
3002 }
3003 return self->operator==(*obj);
3004 }
3005 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3006 wxRealPoint temp, *obj = &temp;
3007 if ( other == Py_None ) return true;
3008 if ( ! wxRealPoint_helper(other, &obj)) {
3009 PyErr_Clear();
3010 return true;
3011 }
3012 return self->operator!=(*obj);
3013 }
3014 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3015 self->x = x;
3016 self->y = y;
3017 }
3018 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3019 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3020 PyObject* tup = PyTuple_New(2);
3021 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3022 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3023 wxPyEndBlockThreads(blocked);
3024 return tup;
3025 }
3026 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3027 wxPoint temp, *obj = &temp;
3028 if ( other == Py_None ) return false;
3029 if ( ! wxPoint_helper(other, &obj) ) {
3030 PyErr_Clear();
3031 return false;
3032 }
3033 return self->operator==(*obj);
3034 }
3035 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3036 wxPoint temp, *obj = &temp;
3037 if ( other == Py_None ) return true;
3038 if ( ! wxPoint_helper(other, &obj)) {
3039 PyErr_Clear();
3040 return true;
3041 }
3042 return self->operator!=(*obj);
3043 }
3044 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3045 self->x = x;
3046 self->y = y;
3047 }
3048 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3049 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3050 PyObject* tup = PyTuple_New(2);
3051 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3052 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3053 wxPyEndBlockThreads(blocked);
3054 return tup;
3055 }
3056 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3057 wxRect temp, *obj = &temp;
3058 if ( other == Py_None ) return false;
3059 if ( ! wxRect_helper(other, &obj) ) {
3060 PyErr_Clear();
3061 return false;
3062 }
3063 return self->operator==(*obj);
3064 }
3065 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3066 wxRect temp, *obj = &temp;
3067 if ( other == Py_None ) return true;
3068 if ( ! wxRect_helper(other, &obj)) {
3069 PyErr_Clear();
3070 return true;
3071 }
3072 return self->operator!=(*obj);
3073 }
3074 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3075 self->x = x;
3076 self->y = y;
3077 self->width = width;
3078 self->height = height;
3079 }
3080 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3082 PyObject* tup = PyTuple_New(4);
3083 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3084 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3085 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3086 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3087 wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090
3091 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3092 wxRegion reg1(*r1);
3093 wxRegion reg2(*r2);
3094 wxRect dest(0,0,0,0);
3095 PyObject* obj;
3096
3097 reg1.Intersect(reg2);
3098 dest = reg1.GetBox();
3099
3100 if (dest != wxRect(0,0,0,0)) {
3101 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3102 wxRect* newRect = new wxRect(dest);
3103 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3104 wxPyEndBlockThreads(blocked);
3105 return obj;
3106 }
3107 Py_INCREF(Py_None);
3108 return Py_None;
3109 }
3110
3111 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3112 wxPoint2D temp, *obj = &temp;
3113 if ( other == Py_None ) return false;
3114 if ( ! wxPoint2D_helper(other, &obj) ) {
3115 PyErr_Clear();
3116 return false;
3117 }
3118 return self->operator==(*obj);
3119 }
3120 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3121 wxPoint2D temp, *obj = &temp;
3122 if ( other == Py_None ) return true;
3123 if ( ! wxPoint2D_helper(other, &obj)) {
3124 PyErr_Clear();
3125 return true;
3126 }
3127 return self->operator!=(*obj);
3128 }
3129 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3130 self->m_x = x;
3131 self->m_y = y;
3132 }
3133 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3135 PyObject* tup = PyTuple_New(2);
3136 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3137 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3138 wxPyEndBlockThreads(blocked);
3139 return tup;
3140 }
3141
3142 #include "wx/wxPython/pyistream.h"
3143
3144 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3145 wxInputStream* wxis = wxPyCBInputStream::create(p);
3146 if (wxis)
3147 return new wxPyInputStream(wxis);
3148 else
3149 return NULL;
3150 }
3151
3152 SWIGINTERN swig_type_info*
3153 SWIG_pchar_descriptor()
3154 {
3155 static int init = 0;
3156 static swig_type_info* info = 0;
3157 if (!init) {
3158 info = SWIG_TypeQuery("_p_char");
3159 init = 1;
3160 }
3161 return info;
3162 }
3163
3164
3165 SWIGINTERNINLINE PyObject *
3166 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3167 {
3168 if (carray) {
3169 if (size > INT_MAX) {
3170 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3171 return pchar_descriptor ?
3172 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3173 } else {
3174 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3175 }
3176 } else {
3177 return SWIG_Py_Void();
3178 }
3179 }
3180
3181
3182 SWIGINTERNINLINE PyObject *
3183 SWIG_From_char (char c)
3184 {
3185 return SWIG_FromCharPtrAndSize(&c,1);
3186 }
3187
3188
3189 SWIGINTERNINLINE PyObject*
3190 SWIG_From_unsigned_SS_long (unsigned long value)
3191 {
3192 return (value > LONG_MAX) ?
3193 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3194 }
3195
3196
3197 SWIGINTERNINLINE PyObject *
3198 SWIG_From_size_t (size_t value)
3199 {
3200 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3201 }
3202
3203
3204 SWIGINTERN int
3205 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3206 {
3207 if (PyString_Check(obj)) {
3208 char *cstr; int len;
3209 PyString_AsStringAndSize(obj, &cstr, &len);
3210 if (cptr) {
3211 if (alloc) {
3212 /*
3213 In python the user should not be able to modify the inner
3214 string representation. To warranty that, if you define
3215 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3216 buffer is always returned.
3217
3218 The default behavior is just to return the pointer value,
3219 so, be careful.
3220 */
3221 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3222 if (*alloc != SWIG_OLDOBJ)
3223 #else
3224 if (*alloc == SWIG_NEWOBJ)
3225 #endif
3226 {
3227 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3228 *alloc = SWIG_NEWOBJ;
3229 }
3230 else {
3231 *cptr = cstr;
3232 *alloc = SWIG_OLDOBJ;
3233 }
3234 } else {
3235 *cptr = PyString_AsString(obj);
3236 }
3237 }
3238 if (psize) *psize = len + 1;
3239 return SWIG_OK;
3240 } else {
3241 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3242 if (pchar_descriptor) {
3243 void* vptr = 0;
3244 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3245 if (cptr) *cptr = (char *) vptr;
3246 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3247 if (alloc) *alloc = SWIG_OLDOBJ;
3248 return SWIG_OK;
3249 }
3250 }
3251 }
3252 return SWIG_TypeError;
3253 }
3254
3255
3256 SWIGINTERN int
3257 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3258 {
3259 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3260 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3261 if (SWIG_IsOK(res)) {
3262 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3263 if (csize <= size) {
3264 if (val) {
3265 if (csize) memcpy(val, cptr, csize*sizeof(char));
3266 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3267 }
3268 if (alloc == SWIG_NEWOBJ) {
3269 delete[] cptr;
3270 res = SWIG_DelNewMask(res);
3271 }
3272 return res;
3273 }
3274 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3275 }
3276 return SWIG_TypeError;
3277 }
3278
3279
3280 SWIGINTERN int
3281 SWIG_AsVal_char (PyObject * obj, char *val)
3282 {
3283 int res = SWIG_AsCharArray(obj, val, 1);
3284 if (!SWIG_IsOK(res)) {
3285 long v;
3286 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3287 if (SWIG_IsOK(res)) {
3288 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3289 if (val) *val = static_cast< char >(v);
3290 } else {
3291 res = SWIG_OverflowError;
3292 }
3293 }
3294 }
3295 return res;
3296 }
3297
3298 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3299 // We use only strings for the streams, not unicode
3300 PyObject* str = PyObject_Str(obj);
3301 if (! str) {
3302 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3303 return;
3304 }
3305 self->Write(PyString_AS_STRING(str),
3306 PyString_GET_SIZE(str));
3307 Py_DECREF(str);
3308 }
3309
3310 #include "wx/wxPython/pyistream.h"
3311
3312
3313 class wxPyFileSystemHandler : public wxFileSystemHandler
3314 {
3315 public:
3316 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3317
3318 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3319 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3320 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3321 DEC_PYCALLBACK_STRING__pure(FindNext);
3322
3323 wxString GetProtocol(const wxString& location) {
3324 return wxFileSystemHandler::GetProtocol(location);
3325 }
3326
3327 wxString GetLeftLocation(const wxString& location) {
3328 return wxFileSystemHandler::GetLeftLocation(location);
3329 }
3330
3331 wxString GetAnchor(const wxString& location) {
3332 return wxFileSystemHandler::GetAnchor(location);
3333 }
3334
3335 wxString GetRightLocation(const wxString& location) {
3336 return wxFileSystemHandler::GetRightLocation(location);
3337 }
3338
3339 wxString GetMimeTypeFromExt(const wxString& location) {
3340 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3341 }
3342
3343 PYPRIVATE;
3344 };
3345
3346
3347 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3348 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3349 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3350 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3351
3352
3353 SWIGINTERN int
3354 SWIG_AsVal_bool (PyObject *obj, bool *val)
3355 {
3356 if (obj == Py_True) {
3357 if (val) *val = true;
3358 return SWIG_OK;
3359 } else if (obj == Py_False) {
3360 if (val) *val = false;
3361 return SWIG_OK;
3362 } else {
3363 long v = 0;
3364 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3365 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3366 return res;
3367 }
3368 }
3369
3370 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3371 wxFileName fname = wxFileSystem::URLToFileName(url);
3372 return fname.GetFullPath();
3373 }
3374
3375 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3376 wxImage& image,
3377 long type) {
3378 wxMemoryFSHandler::AddFile(filename, image, type);
3379 }
3380
3381 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3382 const wxBitmap& bitmap,
3383 long type) {
3384 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3385 }
3386
3387 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3388 PyObject* data) {
3389 if (! PyString_Check(data)) {
3390 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3391 "Expected string object"));
3392 return;
3393 }
3394
3395 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3396 void* ptr = (void*)PyString_AsString(data);
3397 size_t size = PyString_Size(data);
3398 wxPyEndBlockThreads(blocked);
3399
3400 wxMemoryFSHandler::AddFile(filename, ptr, size);
3401 }
3402
3403
3404 #include "wx/wxPython/pyistream.h"
3405
3406
3407 SWIGINTERN int
3408 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3409 {
3410 long v = 0;
3411 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3412 return SWIG_TypeError;
3413 }
3414 else if (val)
3415 *val = (unsigned long)v;
3416 return SWIG_OK;
3417 }
3418
3419
3420 SWIGINTERN int
3421 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3422 {
3423 unsigned long v;
3424 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3425 if (SWIG_IsOK(res)) {
3426 if ((v > UCHAR_MAX)) {
3427 return SWIG_OverflowError;
3428 } else {
3429 if (val) *val = static_cast< unsigned char >(v);
3430 }
3431 }
3432 return res;
3433 }
3434
3435
3436 SWIGINTERNINLINE PyObject *
3437 SWIG_From_unsigned_SS_char (unsigned char value)
3438 {
3439 return SWIG_From_unsigned_SS_long (value);
3440 }
3441
3442 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3443 wxImageHistogramEntry e = (*self)[key];
3444 return e.value;
3445 }
3446 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3447 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3448 wxImageHistogramEntry e = (*self)[key];
3449 return e.value;
3450 }
3451 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3452 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3453 colour.Green(),
3454 colour.Blue());
3455 wxImageHistogramEntry e = (*self)[key];
3456 return e.value;
3457 }
3458
3459 typedef unsigned char* buffer;
3460
3461
3462 // Pull the nested class out to the top level for SWIG's sake
3463 #define wxImage_RGBValue wxImage::RGBValue
3464 #define wxImage_HSVValue wxImage::HSVValue
3465
3466 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3467 if (width > 0 && height > 0)
3468 return new wxImage(width, height, clear);
3469 else
3470 return new wxImage;
3471 }
3472 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3473 return new wxImage(bitmap.ConvertToImage());
3474 }
3475 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3476 if (DATASIZE != width*height*3) {
3477 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3478 return NULL;
3479 }
3480
3481 // Copy the source data so the wxImage can clean it up later
3482 buffer copy = (buffer)malloc(DATASIZE);
3483 if (copy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return NULL;
3486 }
3487 memcpy(copy, data, DATASIZE);
3488 return new wxImage(width, height, copy, false);
3489 }
3490 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3491 if (DATASIZE != width*height*3) {
3492 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3493 return NULL;
3494 }
3495 if (ALPHASIZE != width*height) {
3496 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3497 return NULL;
3498 }
3499
3500 // Copy the source data so the wxImage can clean it up later
3501 buffer dcopy = (buffer)malloc(DATASIZE);
3502 if (dcopy == NULL) {
3503 wxPyBLOCK_THREADS(PyErr_NoMemory());
3504 return NULL;
3505 }
3506 memcpy(dcopy, data, DATASIZE);
3507
3508 buffer acopy = (buffer)malloc(ALPHASIZE);
3509 if (acopy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(acopy, alpha, ALPHASIZE);
3514
3515 return new wxImage(width, height, dcopy, acopy, false);
3516 }
3517 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3518 wxSize size(self->GetWidth(), self->GetHeight());
3519 return size;
3520 }
3521 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3522 buffer data = self->GetData();
3523 int len = self->GetWidth() * self->GetHeight() * 3;
3524 PyObject* rv;
3525 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3526 return rv;
3527 }
3528 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3529 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3530 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3531 return;
3532 }
3533 buffer copy = (buffer)malloc(DATASIZE);
3534 if (copy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return;
3537 }
3538 memcpy(copy, data, DATASIZE);
3539 self->SetData(copy, false);
3540 // wxImage takes ownership of copy...
3541 }
3542 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3543 buffer data = self->GetData();
3544 int len = self->GetWidth() * self->GetHeight() * 3;
3545 PyObject* rv;
3546 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3547 return rv;
3548 }
3549 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3550 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3551 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3552 return;
3553 }
3554 self->SetData(data, true);
3555 }
3556 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3557 buffer data = self->GetAlpha();
3558 if (! data) {
3559 RETURN_NONE();
3560 } else {
3561 int len = self->GetWidth() * self->GetHeight();
3562 PyObject* rv;
3563 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3564 return rv;
3565 }
3566 }
3567 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3568 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3569 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3570 return;
3571 }
3572 buffer acopy = (buffer)malloc(ALPHASIZE);
3573 if (acopy == NULL) {
3574 wxPyBLOCK_THREADS(PyErr_NoMemory());
3575 return;
3576 }
3577 memcpy(acopy, alpha, ALPHASIZE);
3578 self->SetAlpha(acopy, false);
3579 // wxImage takes ownership of acopy...
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 int len = self->GetWidth() * self->GetHeight();
3584 PyObject* rv;
3585 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3586 return rv;
3587 }
3588 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3589 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3590 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3591 return;
3592 }
3593 self->SetAlpha(alpha, true);
3594 }
3595 SWIGINTERN PyObject *wxImage_GetHandlers(){
3596 wxList& list = wxImage::GetHandlers();
3597 return wxPy_ConvertList(&list);
3598 }
3599 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3600 wxBitmap bitmap(*self, depth);
3601 return bitmap;
3602 }
3603 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3604 wxImage mono = self->ConvertToMono( red, green, blue );
3605 wxBitmap bitmap( mono, 1 );
3606 return bitmap;
3607 }
3608 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3609 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3611 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3612 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3615 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3616 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3617 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3618 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3619 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3620 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3621 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3622 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3623
3624 #include <wx/quantize.h>
3625
3626 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3627 return wxQuantize::Quantize(src, dest,
3628 //NULL, // palette
3629 desiredNoColours,
3630 NULL, // eightBitData
3631 flags);
3632 }
3633 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3634 if (PyCallable_Check(func)) {
3635 self->Connect(id, lastId, eventType,
3636 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3637 new wxPyCallback(func));
3638 }
3639 else if (func == Py_None) {
3640 self->Disconnect(id, lastId, eventType,
3641 (wxObjectEventFunction)
3642 &wxPyCallback::EventThunker);
3643 }
3644 else {
3645 wxPyBLOCK_THREADS(
3646 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3647 }
3648 }
3649 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3650 return self->Disconnect(id, lastId, eventType,
3651 (wxObjectEventFunction)
3652 &wxPyCallback::EventThunker);
3653 }
3654 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3655 if (_self && _self != Py_None) {
3656 self->SetClientObject(new wxPyOORClientData(_self, incref));
3657 }
3658 else {
3659 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3660 if (data) {
3661 self->SetClientObject(NULL); // This will delete it too
3662 }
3663 }
3664 }
3665
3666 #if ! wxUSE_HOTKEY
3667 #define wxEVT_HOTKEY -9999
3668 #endif
3669
3670 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3671 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3672 if (data) {
3673 Py_INCREF(data->m_obj);
3674 return data->m_obj;
3675 } else {
3676 Py_INCREF(Py_None);
3677 return Py_None;
3678 }
3679 }
3680 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3681 wxPyClientData* data = new wxPyClientData(clientData);
3682 self->SetClientObject(data);
3683 }
3684 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3685 #if wxUSE_UNICODE
3686 return self->GetUnicodeKey();
3687 #else
3688 return 0;
3689 #endif
3690 }
3691
3692 SWIGINTERNINLINE PyObject *
3693 SWIG_From_unsigned_SS_int (unsigned int value)
3694 {
3695 return SWIG_From_unsigned_SS_long (value);
3696 }
3697
3698
3699 SWIGINTERN int
3700 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3701 {
3702 unsigned long v;
3703 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3704 if (SWIG_IsOK(res)) {
3705 if ((v > UINT_MAX)) {
3706 return SWIG_OverflowError;
3707 } else {
3708 if (val) *val = static_cast< unsigned int >(v);
3709 }
3710 }
3711 return res;
3712 }
3713
3714 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3715 self->m_size = size;
3716 }
3717 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3718 int count = self->GetNumberOfFiles();
3719 wxString* files = self->GetFiles();
3720 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3721 PyObject* list = PyList_New(count);
3722
3723 if (!list) {
3724 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3725 wxPyEndBlockThreads(blocked);
3726 return NULL;
3727 }
3728
3729 for (int i=0; i<count; i++) {
3730 PyList_SetItem(list, i, wx2PyString(files[i]));
3731 }
3732 wxPyEndBlockThreads(blocked);
3733 return list;
3734 }
3735
3736
3737 SWIGINTERN wxPyApp *new_wxPyApp(){
3738 wxPythonApp = new wxPyApp();
3739 return wxPythonApp;
3740 }
3741 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3742
3743 void wxApp_CleanUp() {
3744 __wxPyCleanup();
3745 }
3746
3747
3748 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3749
3750
3751
3752
3753
3754 SWIGINTERNINLINE PyObject *
3755 SWIG_FromCharPtr(const char *cptr)
3756 {
3757 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3758 }
3759
3760
3761 #if 0 // #ifdef __WXMAC__
3762
3763 // A dummy class that raises an exception if used...
3764 class wxEventLoop
3765 {
3766 public:
3767 wxEventLoop() { wxPyRaiseNotImplemented(); }
3768 int Run() { return 0; }
3769 void Exit(int rc = 0) {}
3770 bool Pending() const { return false; }
3771 bool Dispatch() { return false; }
3772 bool IsRunning() const { return false; }
3773 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3774 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3775 };
3776
3777 #else
3778
3779 #include <wx/evtloop.h>
3780
3781 #endif
3782
3783
3784
3785 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3786 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3787 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3788 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3789 wxWindowList& list = self->GetChildren();
3790 return wxPy_ConvertList(&list);
3791 }
3792 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3793 #if wxUSE_HOTKEY
3794 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3795 #else
3796 return false;
3797 #endif
3798 }
3799 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3800
3801
3802
3803 return false;
3804
3805 }
3806 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3807 return wxPyGetWinHandle(self);
3808 }
3809 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3810 self->AssociateHandle((WXWidget)handle);
3811 }
3812 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3813
3814 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3815 return wxWindow::FindWindowById(id, parent);
3816 }
3817
3818 wxWindow* wxFindWindowByName( const wxString& name,
3819 const wxWindow *parent = NULL ) {
3820 return wxWindow::FindWindowByName(name, parent);
3821 }
3822
3823 wxWindow* wxFindWindowByLabel( const wxString& label,
3824 const wxWindow *parent = NULL ) {
3825 return wxWindow::FindWindowByLabel(label, parent);
3826 }
3827
3828
3829 #ifdef __WXMSW__
3830 #include <wx/msw/private.h> // to get wxGetWindowId
3831 #endif
3832
3833
3834 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3835 #ifdef __WXMSW__
3836 WXHWND hWnd = (WXHWND)_hWnd;
3837 long id = wxGetWindowId(hWnd);
3838 wxWindow* win = new wxWindow;
3839 if (parent)
3840 parent->AddChild(win);
3841 win->SetEventHandler(win);
3842 win->SetHWND(hWnd);
3843 win->SetId(id);
3844 win->SubclassWin(hWnd);
3845 win->AdoptAttributesFromHWND();
3846 win->SetupColours();
3847 return win;
3848 #else
3849 wxPyRaiseNotImplemented();
3850 return NULL;
3851 #endif
3852 }
3853
3854
3855 PyObject* GetTopLevelWindows() {
3856 return wxPy_ConvertList(&wxTopLevelWindows);
3857 }
3858
3859
3860 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3861 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3862 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3863
3864 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3865
3866
3867 SWIGINTERNINLINE int
3868 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3869 {
3870 unsigned long v;
3871 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3872 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3873 return res;
3874 }
3875
3876 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3877 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3878 wxMenuItemList& list = self->GetMenuItems();
3879 return wxPy_ConvertList(&list);
3880 }
3881 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3882 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3883 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3884 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3885 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3886 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3887 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3888 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3889 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3890 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3891 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3892 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3893 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3894 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3895 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3896 static const wxString wxPyControlNameStr(wxControlNameStr);
3897 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3898 if (clientData) {
3899 wxPyClientData* data = new wxPyClientData(clientData);
3900 return self->Append(item, data);
3901 } else
3902 return self->Append(item);
3903 }
3904 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3905 if (clientData) {
3906 wxPyClientData* data = new wxPyClientData(clientData);
3907 return self->Insert(item, pos, data);
3908 } else
3909 return self->Insert(item, pos);
3910 }
3911 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3912 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3913 if (data) {
3914 Py_INCREF(data->m_obj);
3915 return data->m_obj;
3916 } else {
3917 Py_INCREF(Py_None);
3918 return Py_None;
3919 }
3920 }
3921 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3922 wxPyClientData* data = new wxPyClientData(clientData);
3923 self->SetClientObject(n, data);
3924 }
3925
3926
3927 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3928 wxPyUserData* data = NULL;
3929 if ( userData ) {
3930 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3931 data = new wxPyUserData(userData);
3932 wxPyEndBlockThreads(blocked);
3933 }
3934 return new wxSizerItem(window, proportion, flag, border, data);
3935 }
3936 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3937 wxPyUserData* data = NULL;
3938 if ( userData ) {
3939 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3940 data = new wxPyUserData(userData);
3941 wxPyEndBlockThreads(blocked);
3942 }
3943 return new wxSizerItem(width, height, proportion, flag, border, data);
3944 }
3945 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3946 wxPyUserData* data = NULL;
3947 if ( userData ) {
3948 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3949 data = new wxPyUserData(userData);
3950 wxPyEndBlockThreads(blocked);
3951 }
3952 return new wxSizerItem(sizer, proportion, flag, border, data);
3953 }
3954
3955 #include <float.h>
3956
3957
3958 SWIGINTERN int
3959 SWIG_AsVal_float (PyObject * obj, float *val)
3960 {
3961 double v;
3962 int res = SWIG_AsVal_double (obj, &v);
3963 if (SWIG_IsOK(res)) {
3964 if ((v < -FLT_MAX || v > FLT_MAX)) {
3965 return SWIG_OverflowError;
3966 } else {
3967 if (val) *val = static_cast< float >(v);
3968 }
3969 }
3970 return res;
3971 }
3972
3973
3974 SWIGINTERNINLINE PyObject *
3975 SWIG_From_float (float value)
3976 {
3977 return SWIG_From_double (value);
3978 }
3979
3980 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3981 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3982 if (data) {
3983 Py_INCREF(data->m_obj);
3984 return data->m_obj;
3985 } else {
3986 Py_INCREF(Py_None);
3987 return Py_None;
3988 }
3989 }
3990 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3991 wxPyUserData* data = NULL;
3992 if ( userData ) {
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 data = new wxPyUserData(userData);
3995 wxPyEndBlockThreads(blocked);
3996 }
3997 self->SetUserData(data);
3998 }
3999
4000 // Figure out the type of the sizer item
4001
4002 struct wxPySizerItemInfo {
4003 wxPySizerItemInfo()
4004 : window(NULL), sizer(NULL), gotSize(false),
4005 size(wxDefaultSize), gotPos(false), pos(-1)
4006 {}
4007
4008 wxWindow* window;
4009 wxSizer* sizer;
4010 bool gotSize;
4011 wxSize size;
4012 bool gotPos;
4013 int pos;
4014 };
4015
4016 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4017
4018 wxPySizerItemInfo info;
4019 wxSize size;
4020 wxSize* sizePtr = &size;
4021
4022 // Find out what the type of the item is
4023 // try wxWindow
4024 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4025 PyErr_Clear();
4026 info.window = NULL;
4027
4028 // try wxSizer
4029 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4030 PyErr_Clear();
4031 info.sizer = NULL;
4032
4033 // try wxSize or (w,h)
4034 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4035 info.size = *sizePtr;
4036 info.gotSize = true;
4037 }
4038
4039 // or a single int
4040 if (checkIdx && PyInt_Check(item)) {
4041 info.pos = PyInt_AsLong(item);
4042 info.gotPos = true;
4043 }
4044 }
4045 }
4046
4047 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4048 // no expected type, figure out what kind of error message to generate
4049 if ( !checkSize && !checkIdx )
4050 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4051 else if ( checkSize && !checkIdx )
4052 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4053 else if ( !checkSize && checkIdx)
4054 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4055 else
4056 // can this one happen?
4057 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4058 }
4059
4060 return info;
4061 }
4062
4063 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4064 if (!self->GetClientObject())
4065 self->SetClientObject(new wxPyOORClientData(_self));
4066 }
4067 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4068
4069 wxPyUserData* data = NULL;
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4072 if ( userData && (info.window || info.sizer || info.gotSize) )
4073 data = new wxPyUserData(userData);
4074 if ( info.sizer )
4075 PyObject_SetAttrString(item,"thisown",Py_False);
4076 wxPyEndBlockThreads(blocked);
4077
4078 // Now call the real Add method if a valid item type was found
4079 if ( info.window )
4080 return self->Add(info.window, proportion, flag, border, data);
4081 else if ( info.sizer )
4082 return self->Add(info.sizer, proportion, flag, border, data);
4083 else if (info.gotSize)
4084 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4085 proportion, flag, border, data);
4086 else
4087 return NULL;
4088 }
4089 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4090
4091 wxPyUserData* data = NULL;
4092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4093 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4094 if ( userData && (info.window || info.sizer || info.gotSize) )
4095 data = new wxPyUserData(userData);
4096 if ( info.sizer )
4097 PyObject_SetAttrString(item,"thisown",Py_False);
4098 wxPyEndBlockThreads(blocked);
4099
4100 // Now call the real Insert method if a valid item type was found
4101 if ( info.window )
4102 return self->Insert(before, info.window, proportion, flag, border, data);
4103 else if ( info.sizer )
4104 return self->Insert(before, info.sizer, proportion, flag, border, data);
4105 else if (info.gotSize)
4106 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4107 proportion, flag, border, data);
4108 else
4109 return NULL;
4110 }
4111 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4112
4113 wxPyUserData* data = NULL;
4114 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4115 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4116 if ( userData && (info.window || info.sizer || info.gotSize) )
4117 data = new wxPyUserData(userData);
4118 if ( info.sizer )
4119 PyObject_SetAttrString(item,"thisown",Py_False);
4120 wxPyEndBlockThreads(blocked);
4121
4122 // Now call the real Prepend method if a valid item type was found
4123 if ( info.window )
4124 return self->Prepend(info.window, proportion, flag, border, data);
4125 else if ( info.sizer )
4126 return self->Prepend(info.sizer, proportion, flag, border, data);
4127 else if (info.gotSize)
4128 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4129 proportion, flag, border, data);
4130 else
4131 return NULL;
4132 }
4133 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4134 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4135 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4136 wxPyEndBlockThreads(blocked);
4137 if ( info.window )
4138 return self->Remove(info.window);
4139 else if ( info.sizer )
4140 return self->Remove(info.sizer);
4141 else if ( info.gotPos )
4142 return self->Remove(info.pos);
4143 else
4144 return false;
4145 }
4146 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4149 wxPyEndBlockThreads(blocked);
4150 if ( info.window )
4151 return self->Detach(info.window);
4152 else if ( info.sizer )
4153 return self->Detach(info.sizer);
4154 else if ( info.gotPos )
4155 return self->Detach(info.pos);
4156 else
4157 return false;
4158 }
4159 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4160 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4161 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4162 wxPyEndBlockThreads(blocked);
4163 if ( info.window )
4164 return self->GetItem(info.window);
4165 else if ( info.sizer )
4166 return self->GetItem(info.sizer);
4167 else if ( info.gotPos )
4168 return self->GetItem(info.pos);
4169 else
4170 return NULL;
4171 }
4172 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4173 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4174 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4175 wxPyEndBlockThreads(blocked);
4176 if ( info.window )
4177 self->SetItemMinSize(info.window, size);
4178 else if ( info.sizer )
4179 self->SetItemMinSize(info.sizer, size);
4180 else if ( info.gotPos )
4181 self->SetItemMinSize(info.pos, size);
4182 }
4183 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4184 wxSizerItemList& list = self->GetChildren();
4185 return wxPy_ConvertList(&list);
4186 }
4187 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4189 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4190 wxPyEndBlockThreads(blocked);
4191 if ( info.window )
4192 return self->Show(info.window, show, recursive);
4193 else if ( info.sizer )
4194 return self->Show(info.sizer, show, recursive);
4195 else if ( info.gotPos )
4196 return self->Show(info.pos, show);
4197 else
4198 return false;
4199 }
4200 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4203 wxPyEndBlockThreads(blocked);
4204 if ( info.window )
4205 return self->IsShown(info.window);
4206 else if ( info.sizer )
4207 return self->IsShown(info.sizer);
4208 else if ( info.gotPos )
4209 return self->IsShown(info.pos);
4210 else
4211 return false;
4212 }
4213
4214 // See pyclasses.h
4215 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4216 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4217 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4218
4219
4220
4221
4222 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4223 {
4224 if (source == Py_None) {
4225 **obj = wxGBPosition(-1,-1);
4226 return true;
4227 }
4228 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4229 }
4230
4231 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4232 {
4233 if (source == Py_None) {
4234 **obj = wxGBSpan(-1,-1);
4235 return true;
4236 }
4237 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4238 }
4239
4240
4241 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4242 wxGBPosition temp, *obj = &temp;
4243 if ( other == Py_None ) return false;
4244 if ( ! wxGBPosition_helper(other, &obj) ) {
4245 PyErr_Clear();
4246 return false;
4247 }
4248 return self->operator==(*obj);
4249 }
4250 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4251 wxGBPosition temp, *obj = &temp;
4252 if ( other == Py_None ) return true;
4253 if ( ! wxGBPosition_helper(other, &obj)) {
4254 PyErr_Clear();
4255 return true;
4256 }
4257 return self->operator!=(*obj);
4258 }
4259 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4260 self->SetRow(row);
4261 self->SetCol(col);
4262 }
4263 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4265 PyObject* tup = PyTuple_New(2);
4266 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4267 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4268 wxPyEndBlockThreads(blocked);
4269 return tup;
4270 }
4271 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4272 wxGBSpan temp, *obj = &temp;
4273 if ( other == Py_None ) return false;
4274 if ( ! wxGBSpan_helper(other, &obj) ) {
4275 PyErr_Clear();
4276 return false;
4277 }
4278 return self->operator==(*obj);
4279 }
4280 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4281 wxGBSpan temp, *obj = &temp;
4282 if ( other == Py_None ) return true;
4283 if ( ! wxGBSpan_helper(other, &obj)) {
4284 PyErr_Clear();
4285 return true;
4286 }
4287 return self->operator!=(*obj);
4288 }
4289 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4290 self->SetRowspan(rowspan);
4291 self->SetColspan(colspan);
4292 }
4293 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4294 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4295 PyObject* tup = PyTuple_New(2);
4296 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4297 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4298 wxPyEndBlockThreads(blocked);
4299 return tup;
4300 }
4301 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4302 wxPyUserData* data = NULL;
4303 if ( userData ) {
4304 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4305 data = new wxPyUserData(userData);
4306 wxPyEndBlockThreads(blocked);
4307 }
4308 return new wxGBSizerItem(window, pos, span, flag, border, data);
4309 }
4310 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4311 wxPyUserData* data = NULL;
4312 if ( userData ) {
4313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4314 data = new wxPyUserData(userData);
4315 wxPyEndBlockThreads(blocked);
4316 }
4317 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4329 int row, col;
4330 self->GetEndPos(row, col);
4331 return wxGBPosition(row, col);
4332 }
4333 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4334
4335 wxPyUserData* data = NULL;
4336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4337 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4338 if ( userData && (info.window || info.sizer || info.gotSize) )
4339 data = new wxPyUserData(userData);
4340 if ( info.sizer )
4341 PyObject_SetAttrString(item,"thisown",Py_False);
4342 wxPyEndBlockThreads(blocked);
4343
4344 // Now call the real Add method if a valid item type was found
4345 if ( info.window )
4346 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4347 else if ( info.sizer )
4348 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4349 else if (info.gotSize)
4350 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4351 pos, span, flag, border, data);
4352 return NULL;
4353 }
4354
4355
4356 #ifdef __cplusplus
4357 extern "C" {
4358 #endif
4359 SWIGINTERN int EmptyString_set(PyObject *) {
4360 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4361 return 1;
4362 }
4363
4364
4365 SWIGINTERN PyObject *EmptyString_get(void) {
4366 PyObject *pyobj = 0;
4367
4368 {
4369 #if wxUSE_UNICODE
4370 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4371 #else
4372 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4373 #endif
4374 }
4375 return pyobj;
4376 }
4377
4378
4379 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4380 PyObject *resultobj = 0;
4381 wxObject *arg1 = (wxObject *) 0 ;
4382 wxString result;
4383 void *argp1 = 0 ;
4384 int res1 = 0 ;
4385 PyObject *swig_obj[1] ;
4386
4387 if (!args) SWIG_fail;
4388 swig_obj[0] = args;
4389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4390 if (!SWIG_IsOK(res1)) {
4391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4392 }
4393 arg1 = reinterpret_cast< wxObject * >(argp1);
4394 {
4395 PyThreadState* __tstate = wxPyBeginAllowThreads();
4396 result = wxObject_GetClassName(arg1);
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4414 PyObject *resultobj = 0;
4415 wxObject *arg1 = (wxObject *) 0 ;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 wxObject_Destroy(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 resultobj = SWIG_Py_Void();
4434 return resultobj;
4435 fail:
4436 return NULL;
4437 }
4438
4439
4440 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4441 PyObject *obj;
4442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4443 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4444 return SWIG_Py_Void();
4445 }
4446
4447 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4448 PyObject *resultobj = 0;
4449 wxSize *arg1 = (wxSize *) 0 ;
4450 int arg2 ;
4451 void *argp1 = 0 ;
4452 int res1 = 0 ;
4453 int val2 ;
4454 int ecode2 = 0 ;
4455 PyObject *swig_obj[2] ;
4456
4457 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4459 if (!SWIG_IsOK(res1)) {
4460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4461 }
4462 arg1 = reinterpret_cast< wxSize * >(argp1);
4463 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4464 if (!SWIG_IsOK(ecode2)) {
4465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4466 }
4467 arg2 = static_cast< int >(val2);
4468 if (arg1) (arg1)->x = arg2;
4469
4470 resultobj = SWIG_Py_Void();
4471 return resultobj;
4472 fail:
4473 return NULL;
4474 }
4475
4476
4477 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4478 PyObject *resultobj = 0;
4479 wxSize *arg1 = (wxSize *) 0 ;
4480 int result;
4481 void *argp1 = 0 ;
4482 int res1 = 0 ;
4483 PyObject *swig_obj[1] ;
4484
4485 if (!args) SWIG_fail;
4486 swig_obj[0] = args;
4487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4488 if (!SWIG_IsOK(res1)) {
4489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4490 }
4491 arg1 = reinterpret_cast< wxSize * >(argp1);
4492 result = (int) ((arg1)->x);
4493 resultobj = SWIG_From_int(static_cast< int >(result));
4494 return resultobj;
4495 fail:
4496 return NULL;
4497 }
4498
4499
4500 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4501 PyObject *resultobj = 0;
4502 wxSize *arg1 = (wxSize *) 0 ;
4503 int arg2 ;
4504 void *argp1 = 0 ;
4505 int res1 = 0 ;
4506 int val2 ;
4507 int ecode2 = 0 ;
4508 PyObject *swig_obj[2] ;
4509
4510 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4512 if (!SWIG_IsOK(res1)) {
4513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4514 }
4515 arg1 = reinterpret_cast< wxSize * >(argp1);
4516 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4517 if (!SWIG_IsOK(ecode2)) {
4518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4519 }
4520 arg2 = static_cast< int >(val2);
4521 if (arg1) (arg1)->y = arg2;
4522
4523 resultobj = SWIG_Py_Void();
4524 return resultobj;
4525 fail:
4526 return NULL;
4527 }
4528
4529
4530 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4531 PyObject *resultobj = 0;
4532 wxSize *arg1 = (wxSize *) 0 ;
4533 int result;
4534 void *argp1 = 0 ;
4535 int res1 = 0 ;
4536 PyObject *swig_obj[1] ;
4537
4538 if (!args) SWIG_fail;
4539 swig_obj[0] = args;
4540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4541 if (!SWIG_IsOK(res1)) {
4542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4543 }
4544 arg1 = reinterpret_cast< wxSize * >(argp1);
4545 result = (int) ((arg1)->y);
4546 resultobj = SWIG_From_int(static_cast< int >(result));
4547 return resultobj;
4548 fail:
4549 return NULL;
4550 }
4551
4552
4553 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4554 PyObject *resultobj = 0;
4555 int arg1 = (int) 0 ;
4556 int arg2 = (int) 0 ;
4557 wxSize *result = 0 ;
4558 int val1 ;
4559 int ecode1 = 0 ;
4560 int val2 ;
4561 int ecode2 = 0 ;
4562 PyObject * obj0 = 0 ;
4563 PyObject * obj1 = 0 ;
4564 char * kwnames[] = {
4565 (char *) "w",(char *) "h", NULL
4566 };
4567
4568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4569 if (obj0) {
4570 ecode1 = SWIG_AsVal_int(obj0, &val1);
4571 if (!SWIG_IsOK(ecode1)) {
4572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4573 }
4574 arg1 = static_cast< int >(val1);
4575 }
4576 if (obj1) {
4577 ecode2 = SWIG_AsVal_int(obj1, &val2);
4578 if (!SWIG_IsOK(ecode2)) {
4579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4580 }
4581 arg2 = static_cast< int >(val2);
4582 }
4583 {
4584 PyThreadState* __tstate = wxPyBeginAllowThreads();
4585 result = (wxSize *)new wxSize(arg1,arg2);
4586 wxPyEndAllowThreads(__tstate);
4587 if (PyErr_Occurred()) SWIG_fail;
4588 }
4589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4590 return resultobj;
4591 fail:
4592 return NULL;
4593 }
4594
4595
4596 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4597 PyObject *resultobj = 0;
4598 wxSize *arg1 = (wxSize *) 0 ;
4599 void *argp1 = 0 ;
4600 int res1 = 0 ;
4601 PyObject *swig_obj[1] ;
4602
4603 if (!args) SWIG_fail;
4604 swig_obj[0] = args;
4605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4606 if (!SWIG_IsOK(res1)) {
4607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4608 }
4609 arg1 = reinterpret_cast< wxSize * >(argp1);
4610 {
4611 PyThreadState* __tstate = wxPyBeginAllowThreads();
4612 delete arg1;
4613
4614 wxPyEndAllowThreads(__tstate);
4615 if (PyErr_Occurred()) SWIG_fail;
4616 }
4617 resultobj = SWIG_Py_Void();
4618 return resultobj;
4619 fail:
4620 return NULL;
4621 }
4622
4623
4624 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4625 PyObject *resultobj = 0;
4626 wxSize *arg1 = (wxSize *) 0 ;
4627 PyObject *arg2 = (PyObject *) 0 ;
4628 bool result;
4629 void *argp1 = 0 ;
4630 int res1 = 0 ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 char * kwnames[] = {
4634 (char *) "self",(char *) "other", NULL
4635 };
4636
4637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 arg2 = obj1;
4644 {
4645 result = (bool)wxSize___eq__(arg1,arg2);
4646 if (PyErr_Occurred()) SWIG_fail;
4647 }
4648 {
4649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4650 }
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___ne__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 wxSize *arg2 = 0 ;
4694 wxSize result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 wxSize temp2 ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 char * kwnames[] = {
4701 (char *) "self",(char *) "sz", NULL
4702 };
4703
4704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 {
4711 arg2 = &temp2;
4712 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4713 }
4714 {
4715 PyThreadState* __tstate = wxPyBeginAllowThreads();
4716 result = (arg1)->operator +((wxSize const &)*arg2);
4717 wxPyEndAllowThreads(__tstate);
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj = 0;
4729 wxSize *arg1 = (wxSize *) 0 ;
4730 wxSize *arg2 = 0 ;
4731 wxSize result;
4732 void *argp1 = 0 ;
4733 int res1 = 0 ;
4734 wxSize temp2 ;
4735 PyObject * obj0 = 0 ;
4736 PyObject * obj1 = 0 ;
4737 char * kwnames[] = {
4738 (char *) "self",(char *) "sz", NULL
4739 };
4740
4741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4743 if (!SWIG_IsOK(res1)) {
4744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4745 }
4746 arg1 = reinterpret_cast< wxSize * >(argp1);
4747 {
4748 arg2 = &temp2;
4749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4750 }
4751 {
4752 PyThreadState* __tstate = wxPyBeginAllowThreads();
4753 result = (arg1)->operator -((wxSize const &)*arg2);
4754 wxPyEndAllowThreads(__tstate);
4755 if (PyErr_Occurred()) SWIG_fail;
4756 }
4757 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4758 return resultobj;
4759 fail:
4760 return NULL;
4761 }
4762
4763
4764 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4765 PyObject *resultobj = 0;
4766 wxSize *arg1 = (wxSize *) 0 ;
4767 wxSize *arg2 = 0 ;
4768 void *argp1 = 0 ;
4769 int res1 = 0 ;
4770 wxSize temp2 ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 char * kwnames[] = {
4774 (char *) "self",(char *) "sz", NULL
4775 };
4776
4777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4779 if (!SWIG_IsOK(res1)) {
4780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4781 }
4782 arg1 = reinterpret_cast< wxSize * >(argp1);
4783 {
4784 arg2 = &temp2;
4785 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 (arg1)->IncTo((wxSize const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_Py_Void();
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 wxSize *arg2 = 0 ;
4804 void *argp1 = 0 ;
4805 int res1 = 0 ;
4806 wxSize temp2 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "sz", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 {
4820 arg2 = &temp2;
4821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 (arg1)->DecTo((wxSize const &)*arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 resultobj = SWIG_Py_Void();
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 wxSize *arg1 = (wxSize *) 0 ;
4839 int arg2 ;
4840 int arg3 ;
4841 void *argp1 = 0 ;
4842 int res1 = 0 ;
4843 int val2 ;
4844 int ecode2 = 0 ;
4845 int val3 ;
4846 int ecode3 = 0 ;
4847 PyObject * obj0 = 0 ;
4848 PyObject * obj1 = 0 ;
4849 PyObject * obj2 = 0 ;
4850 char * kwnames[] = {
4851 (char *) "self",(char *) "w",(char *) "h", NULL
4852 };
4853
4854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4856 if (!SWIG_IsOK(res1)) {
4857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4858 }
4859 arg1 = reinterpret_cast< wxSize * >(argp1);
4860 ecode2 = SWIG_AsVal_int(obj1, &val2);
4861 if (!SWIG_IsOK(ecode2)) {
4862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4863 }
4864 arg2 = static_cast< int >(val2);
4865 ecode3 = SWIG_AsVal_int(obj2, &val3);
4866 if (!SWIG_IsOK(ecode3)) {
4867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4868 }
4869 arg3 = static_cast< int >(val3);
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 (arg1)->Set(arg2,arg3);
4873 wxPyEndAllowThreads(__tstate);
4874 if (PyErr_Occurred()) SWIG_fail;
4875 }
4876 resultobj = SWIG_Py_Void();
4877 return resultobj;
4878 fail:
4879 return NULL;
4880 }
4881
4882
4883 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj = 0;
4885 wxSize *arg1 = (wxSize *) 0 ;
4886 int arg2 ;
4887 void *argp1 = 0 ;
4888 int res1 = 0 ;
4889 int val2 ;
4890 int ecode2 = 0 ;
4891 PyObject * obj0 = 0 ;
4892 PyObject * obj1 = 0 ;
4893 char * kwnames[] = {
4894 (char *) "self",(char *) "w", NULL
4895 };
4896
4897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4899 if (!SWIG_IsOK(res1)) {
4900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4901 }
4902 arg1 = reinterpret_cast< wxSize * >(argp1);
4903 ecode2 = SWIG_AsVal_int(obj1, &val2);
4904 if (!SWIG_IsOK(ecode2)) {
4905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4906 }
4907 arg2 = static_cast< int >(val2);
4908 {
4909 PyThreadState* __tstate = wxPyBeginAllowThreads();
4910 (arg1)->SetWidth(arg2);
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = SWIG_Py_Void();
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4922 PyObject *resultobj = 0;
4923 wxSize *arg1 = (wxSize *) 0 ;
4924 int arg2 ;
4925 void *argp1 = 0 ;
4926 int res1 = 0 ;
4927 int val2 ;
4928 int ecode2 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 char * kwnames[] = {
4932 (char *) "self",(char *) "h", NULL
4933 };
4934
4935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4937 if (!SWIG_IsOK(res1)) {
4938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4939 }
4940 arg1 = reinterpret_cast< wxSize * >(argp1);
4941 ecode2 = SWIG_AsVal_int(obj1, &val2);
4942 if (!SWIG_IsOK(ecode2)) {
4943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4944 }
4945 arg2 = static_cast< int >(val2);
4946 {
4947 PyThreadState* __tstate = wxPyBeginAllowThreads();
4948 (arg1)->SetHeight(arg2);
4949 wxPyEndAllowThreads(__tstate);
4950 if (PyErr_Occurred()) SWIG_fail;
4951 }
4952 resultobj = SWIG_Py_Void();
4953 return resultobj;
4954 fail:
4955 return NULL;
4956 }
4957
4958
4959 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4960 PyObject *resultobj = 0;
4961 wxSize *arg1 = (wxSize *) 0 ;
4962 int result;
4963 void *argp1 = 0 ;
4964 int res1 = 0 ;
4965 PyObject *swig_obj[1] ;
4966
4967 if (!args) SWIG_fail;
4968 swig_obj[0] = args;
4969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4970 if (!SWIG_IsOK(res1)) {
4971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4972 }
4973 arg1 = reinterpret_cast< wxSize * >(argp1);
4974 {
4975 PyThreadState* __tstate = wxPyBeginAllowThreads();
4976 result = (int)((wxSize const *)arg1)->GetWidth();
4977 wxPyEndAllowThreads(__tstate);
4978 if (PyErr_Occurred()) SWIG_fail;
4979 }
4980 resultobj = SWIG_From_int(static_cast< int >(result));
4981 return resultobj;
4982 fail:
4983 return NULL;
4984 }
4985
4986
4987 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4988 PyObject *resultobj = 0;
4989 wxSize *arg1 = (wxSize *) 0 ;
4990 int result;
4991 void *argp1 = 0 ;
4992 int res1 = 0 ;
4993 PyObject *swig_obj[1] ;
4994
4995 if (!args) SWIG_fail;
4996 swig_obj[0] = args;
4997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5000 }
5001 arg1 = reinterpret_cast< wxSize * >(argp1);
5002 {
5003 PyThreadState* __tstate = wxPyBeginAllowThreads();
5004 result = (int)((wxSize const *)arg1)->GetHeight();
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 resultobj = SWIG_From_int(static_cast< int >(result));
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5016 PyObject *resultobj = 0;
5017 wxSize *arg1 = (wxSize *) 0 ;
5018 bool result;
5019 void *argp1 = 0 ;
5020 int res1 = 0 ;
5021 PyObject *swig_obj[1] ;
5022
5023 if (!args) SWIG_fail;
5024 swig_obj[0] = args;
5025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5026 if (!SWIG_IsOK(res1)) {
5027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5028 }
5029 arg1 = reinterpret_cast< wxSize * >(argp1);
5030 {
5031 PyThreadState* __tstate = wxPyBeginAllowThreads();
5032 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5033 wxPyEndAllowThreads(__tstate);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 {
5037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5038 }
5039 return resultobj;
5040 fail:
5041 return NULL;
5042 }
5043
5044
5045 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5046 PyObject *resultobj = 0;
5047 wxSize *arg1 = (wxSize *) 0 ;
5048 wxSize *arg2 = 0 ;
5049 void *argp1 = 0 ;
5050 int res1 = 0 ;
5051 wxSize temp2 ;
5052 PyObject * obj0 = 0 ;
5053 PyObject * obj1 = 0 ;
5054 char * kwnames[] = {
5055 (char *) "self",(char *) "size", NULL
5056 };
5057
5058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",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_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5062 }
5063 arg1 = reinterpret_cast< wxSize * >(argp1);
5064 {
5065 arg2 = &temp2;
5066 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5067 }
5068 {
5069 PyThreadState* __tstate = wxPyBeginAllowThreads();
5070 (arg1)->SetDefaults((wxSize const &)*arg2);
5071 wxPyEndAllowThreads(__tstate);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 PyObject *result = 0 ;
5085 void *argp1 = 0 ;
5086 int res1 = 0 ;
5087 PyObject *swig_obj[1] ;
5088
5089 if (!args) SWIG_fail;
5090 swig_obj[0] = args;
5091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5092 if (!SWIG_IsOK(res1)) {
5093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5094 }
5095 arg1 = reinterpret_cast< wxSize * >(argp1);
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 result = (PyObject *)wxSize_Get(arg1);
5099 wxPyEndAllowThreads(__tstate);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = result;
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5110 PyObject *obj;
5111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5112 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5113 return SWIG_Py_Void();
5114 }
5115
5116 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5117 return SWIG_Python_InitShadowInstance(args);
5118 }
5119
5120 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5121 PyObject *resultobj = 0;
5122 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5123 double arg2 ;
5124 void *argp1 = 0 ;
5125 int res1 = 0 ;
5126 double val2 ;
5127 int ecode2 = 0 ;
5128 PyObject *swig_obj[2] ;
5129
5130 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5132 if (!SWIG_IsOK(res1)) {
5133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5134 }
5135 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5136 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5137 if (!SWIG_IsOK(ecode2)) {
5138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5139 }
5140 arg2 = static_cast< double >(val2);
5141 if (arg1) (arg1)->x = arg2;
5142
5143 resultobj = SWIG_Py_Void();
5144 return resultobj;
5145 fail:
5146 return NULL;
5147 }
5148
5149
5150 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5151 PyObject *resultobj = 0;
5152 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5153 double result;
5154 void *argp1 = 0 ;
5155 int res1 = 0 ;
5156 PyObject *swig_obj[1] ;
5157
5158 if (!args) SWIG_fail;
5159 swig_obj[0] = args;
5160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5161 if (!SWIG_IsOK(res1)) {
5162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5163 }
5164 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5165 result = (double) ((arg1)->x);
5166 resultobj = SWIG_From_double(static_cast< double >(result));
5167 return resultobj;
5168 fail:
5169 return NULL;
5170 }
5171
5172
5173 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5174 PyObject *resultobj = 0;
5175 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5176 double arg2 ;
5177 void *argp1 = 0 ;
5178 int res1 = 0 ;
5179 double val2 ;
5180 int ecode2 = 0 ;
5181 PyObject *swig_obj[2] ;
5182
5183 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5185 if (!SWIG_IsOK(res1)) {
5186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5187 }
5188 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5189 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5190 if (!SWIG_IsOK(ecode2)) {
5191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5192 }
5193 arg2 = static_cast< double >(val2);
5194 if (arg1) (arg1)->y = arg2;
5195
5196 resultobj = SWIG_Py_Void();
5197 return resultobj;
5198 fail:
5199 return NULL;
5200 }
5201
5202
5203 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5204 PyObject *resultobj = 0;
5205 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5206 double result;
5207 void *argp1 = 0 ;
5208 int res1 = 0 ;
5209 PyObject *swig_obj[1] ;
5210
5211 if (!args) SWIG_fail;
5212 swig_obj[0] = args;
5213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5214 if (!SWIG_IsOK(res1)) {
5215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5216 }
5217 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5218 result = (double) ((arg1)->y);
5219 resultobj = SWIG_From_double(static_cast< double >(result));
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj = 0;
5228 double arg1 = (double) 0.0 ;
5229 double arg2 = (double) 0.0 ;
5230 wxRealPoint *result = 0 ;
5231 double val1 ;
5232 int ecode1 = 0 ;
5233 double val2 ;
5234 int ecode2 = 0 ;
5235 PyObject * obj0 = 0 ;
5236 PyObject * obj1 = 0 ;
5237 char * kwnames[] = {
5238 (char *) "x",(char *) "y", NULL
5239 };
5240
5241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5242 if (obj0) {
5243 ecode1 = SWIG_AsVal_double(obj0, &val1);
5244 if (!SWIG_IsOK(ecode1)) {
5245 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5246 }
5247 arg1 = static_cast< double >(val1);
5248 }
5249 if (obj1) {
5250 ecode2 = SWIG_AsVal_double(obj1, &val2);
5251 if (!SWIG_IsOK(ecode2)) {
5252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5253 }
5254 arg2 = static_cast< double >(val2);
5255 }
5256 {
5257 PyThreadState* __tstate = wxPyBeginAllowThreads();
5258 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5259 wxPyEndAllowThreads(__tstate);
5260 if (PyErr_Occurred()) SWIG_fail;
5261 }
5262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5263 return resultobj;
5264 fail:
5265 return NULL;
5266 }
5267
5268
5269 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5270 PyObject *resultobj = 0;
5271 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 PyObject *swig_obj[1] ;
5275
5276 if (!args) SWIG_fail;
5277 swig_obj[0] = args;
5278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 {
5284 PyThreadState* __tstate = wxPyBeginAllowThreads();
5285 delete arg1;
5286
5287 wxPyEndAllowThreads(__tstate);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 resultobj = SWIG_Py_Void();
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5298 PyObject *resultobj = 0;
5299 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5300 PyObject *arg2 = (PyObject *) 0 ;
5301 bool result;
5302 void *argp1 = 0 ;
5303 int res1 = 0 ;
5304 PyObject * obj0 = 0 ;
5305 PyObject * obj1 = 0 ;
5306 char * kwnames[] = {
5307 (char *) "self",(char *) "other", NULL
5308 };
5309
5310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5312 if (!SWIG_IsOK(res1)) {
5313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5314 }
5315 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5316 arg2 = obj1;
5317 {
5318 result = (bool)wxRealPoint___eq__(arg1,arg2);
5319 if (PyErr_Occurred()) SWIG_fail;
5320 }
5321 {
5322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5323 }
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5331 PyObject *resultobj = 0;
5332 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5333 PyObject *arg2 = (PyObject *) 0 ;
5334 bool result;
5335 void *argp1 = 0 ;
5336 int res1 = 0 ;
5337 PyObject * obj0 = 0 ;
5338 PyObject * obj1 = 0 ;
5339 char * kwnames[] = {
5340 (char *) "self",(char *) "other", NULL
5341 };
5342
5343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 arg2 = obj1;
5350 {
5351 result = (bool)wxRealPoint___ne__(arg1,arg2);
5352 if (PyErr_Occurred()) SWIG_fail;
5353 }
5354 {
5355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5356 }
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 wxRealPoint *arg2 = 0 ;
5367 wxRealPoint result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 wxRealPoint temp2 ;
5371 PyObject * obj0 = 0 ;
5372 PyObject * obj1 = 0 ;
5373 char * kwnames[] = {
5374 (char *) "self",(char *) "pt", NULL
5375 };
5376
5377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5379 if (!SWIG_IsOK(res1)) {
5380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5381 }
5382 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5383 {
5384 arg2 = &temp2;
5385 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5386 }
5387 {
5388 PyThreadState* __tstate = wxPyBeginAllowThreads();
5389 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5390 wxPyEndAllowThreads(__tstate);
5391 if (PyErr_Occurred()) SWIG_fail;
5392 }
5393 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5394 return resultobj;
5395 fail:
5396 return NULL;
5397 }
5398
5399
5400 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5401 PyObject *resultobj = 0;
5402 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5403 wxRealPoint *arg2 = 0 ;
5404 wxRealPoint result;
5405 void *argp1 = 0 ;
5406 int res1 = 0 ;
5407 wxRealPoint temp2 ;
5408 PyObject * obj0 = 0 ;
5409 PyObject * obj1 = 0 ;
5410 char * kwnames[] = {
5411 (char *) "self",(char *) "pt", NULL
5412 };
5413
5414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5416 if (!SWIG_IsOK(res1)) {
5417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5418 }
5419 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5420 {
5421 arg2 = &temp2;
5422 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5423 }
5424 {
5425 PyThreadState* __tstate = wxPyBeginAllowThreads();
5426 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5427 wxPyEndAllowThreads(__tstate);
5428 if (PyErr_Occurred()) SWIG_fail;
5429 }
5430 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5438 PyObject *resultobj = 0;
5439 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5440 double arg2 ;
5441 double arg3 ;
5442 void *argp1 = 0 ;
5443 int res1 = 0 ;
5444 double val2 ;
5445 int ecode2 = 0 ;
5446 double val3 ;
5447 int ecode3 = 0 ;
5448 PyObject * obj0 = 0 ;
5449 PyObject * obj1 = 0 ;
5450 PyObject * obj2 = 0 ;
5451 char * kwnames[] = {
5452 (char *) "self",(char *) "x",(char *) "y", NULL
5453 };
5454
5455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5457 if (!SWIG_IsOK(res1)) {
5458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5459 }
5460 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5461 ecode2 = SWIG_AsVal_double(obj1, &val2);
5462 if (!SWIG_IsOK(ecode2)) {
5463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5464 }
5465 arg2 = static_cast< double >(val2);
5466 ecode3 = SWIG_AsVal_double(obj2, &val3);
5467 if (!SWIG_IsOK(ecode3)) {
5468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5469 }
5470 arg3 = static_cast< double >(val3);
5471 {
5472 PyThreadState* __tstate = wxPyBeginAllowThreads();
5473 wxRealPoint_Set(arg1,arg2,arg3);
5474 wxPyEndAllowThreads(__tstate);
5475 if (PyErr_Occurred()) SWIG_fail;
5476 }
5477 resultobj = SWIG_Py_Void();
5478 return resultobj;
5479 fail:
5480 return NULL;
5481 }
5482
5483
5484 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5485 PyObject *resultobj = 0;
5486 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5487 PyObject *result = 0 ;
5488 void *argp1 = 0 ;
5489 int res1 = 0 ;
5490 PyObject *swig_obj[1] ;
5491
5492 if (!args) SWIG_fail;
5493 swig_obj[0] = args;
5494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5495 if (!SWIG_IsOK(res1)) {
5496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5497 }
5498 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5499 {
5500 PyThreadState* __tstate = wxPyBeginAllowThreads();
5501 result = (PyObject *)wxRealPoint_Get(arg1);
5502 wxPyEndAllowThreads(__tstate);
5503 if (PyErr_Occurred()) SWIG_fail;
5504 }
5505 resultobj = result;
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5513 PyObject *obj;
5514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5515 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5516 return SWIG_Py_Void();
5517 }
5518
5519 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5520 return SWIG_Python_InitShadowInstance(args);
5521 }
5522
5523 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5524 PyObject *resultobj = 0;
5525 wxPoint *arg1 = (wxPoint *) 0 ;
5526 int arg2 ;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 int val2 ;
5530 int ecode2 = 0 ;
5531 PyObject *swig_obj[2] ;
5532
5533 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5535 if (!SWIG_IsOK(res1)) {
5536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5537 }
5538 arg1 = reinterpret_cast< wxPoint * >(argp1);
5539 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5540 if (!SWIG_IsOK(ecode2)) {
5541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5542 }
5543 arg2 = static_cast< int >(val2);
5544 if (arg1) (arg1)->x = arg2;
5545
5546 resultobj = SWIG_Py_Void();
5547 return resultobj;
5548 fail:
5549 return NULL;
5550 }
5551
5552
5553 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5554 PyObject *resultobj = 0;
5555 wxPoint *arg1 = (wxPoint *) 0 ;
5556 int result;
5557 void *argp1 = 0 ;
5558 int res1 = 0 ;
5559 PyObject *swig_obj[1] ;
5560
5561 if (!args) SWIG_fail;
5562 swig_obj[0] = args;
5563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5564 if (!SWIG_IsOK(res1)) {
5565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5566 }
5567 arg1 = reinterpret_cast< wxPoint * >(argp1);
5568 result = (int) ((arg1)->x);
5569 resultobj = SWIG_From_int(static_cast< int >(result));
5570 return resultobj;
5571 fail:
5572 return NULL;
5573 }
5574
5575
5576 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5577 PyObject *resultobj = 0;
5578 wxPoint *arg1 = (wxPoint *) 0 ;
5579 int arg2 ;
5580 void *argp1 = 0 ;
5581 int res1 = 0 ;
5582 int val2 ;
5583 int ecode2 = 0 ;
5584 PyObject *swig_obj[2] ;
5585
5586 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5588 if (!SWIG_IsOK(res1)) {
5589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5590 }
5591 arg1 = reinterpret_cast< wxPoint * >(argp1);
5592 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5593 if (!SWIG_IsOK(ecode2)) {
5594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5595 }
5596 arg2 = static_cast< int >(val2);
5597 if (arg1) (arg1)->y = arg2;
5598
5599 resultobj = SWIG_Py_Void();
5600 return resultobj;
5601 fail:
5602 return NULL;
5603 }
5604
5605
5606 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5607 PyObject *resultobj = 0;
5608 wxPoint *arg1 = (wxPoint *) 0 ;
5609 int result;
5610 void *argp1 = 0 ;
5611 int res1 = 0 ;
5612 PyObject *swig_obj[1] ;
5613
5614 if (!args) SWIG_fail;
5615 swig_obj[0] = args;
5616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5617 if (!SWIG_IsOK(res1)) {
5618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5619 }
5620 arg1 = reinterpret_cast< wxPoint * >(argp1);
5621 result = (int) ((arg1)->y);
5622 resultobj = SWIG_From_int(static_cast< int >(result));
5623 return resultobj;
5624 fail:
5625 return NULL;
5626 }
5627
5628
5629 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5630 PyObject *resultobj = 0;
5631 int arg1 = (int) 0 ;
5632 int arg2 = (int) 0 ;
5633 wxPoint *result = 0 ;
5634 int val1 ;
5635 int ecode1 = 0 ;
5636 int val2 ;
5637 int ecode2 = 0 ;
5638 PyObject * obj0 = 0 ;
5639 PyObject * obj1 = 0 ;
5640 char * kwnames[] = {
5641 (char *) "x",(char *) "y", NULL
5642 };
5643
5644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5645 if (obj0) {
5646 ecode1 = SWIG_AsVal_int(obj0, &val1);
5647 if (!SWIG_IsOK(ecode1)) {
5648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5649 }
5650 arg1 = static_cast< int >(val1);
5651 }
5652 if (obj1) {
5653 ecode2 = SWIG_AsVal_int(obj1, &val2);
5654 if (!SWIG_IsOK(ecode2)) {
5655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5656 }
5657 arg2 = static_cast< int >(val2);
5658 }
5659 {
5660 PyThreadState* __tstate = wxPyBeginAllowThreads();
5661 result = (wxPoint *)new wxPoint(arg1,arg2);
5662 wxPyEndAllowThreads(__tstate);
5663 if (PyErr_Occurred()) SWIG_fail;
5664 }
5665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5666 return resultobj;
5667 fail:
5668 return NULL;
5669 }
5670
5671
5672 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5673 PyObject *resultobj = 0;
5674 wxPoint *arg1 = (wxPoint *) 0 ;
5675 void *argp1 = 0 ;
5676 int res1 = 0 ;
5677 PyObject *swig_obj[1] ;
5678
5679 if (!args) SWIG_fail;
5680 swig_obj[0] = args;
5681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5684 }
5685 arg1 = reinterpret_cast< wxPoint * >(argp1);
5686 {
5687 PyThreadState* __tstate = wxPyBeginAllowThreads();
5688 delete arg1;
5689
5690 wxPyEndAllowThreads(__tstate);
5691 if (PyErr_Occurred()) SWIG_fail;
5692 }
5693 resultobj = SWIG_Py_Void();
5694 return resultobj;
5695 fail:
5696 return NULL;
5697 }
5698
5699
5700 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5701 PyObject *resultobj = 0;
5702 wxPoint *arg1 = (wxPoint *) 0 ;
5703 PyObject *arg2 = (PyObject *) 0 ;
5704 bool result;
5705 void *argp1 = 0 ;
5706 int res1 = 0 ;
5707 PyObject * obj0 = 0 ;
5708 PyObject * obj1 = 0 ;
5709 char * kwnames[] = {
5710 (char *) "self",(char *) "other", NULL
5711 };
5712
5713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5715 if (!SWIG_IsOK(res1)) {
5716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5717 }
5718 arg1 = reinterpret_cast< wxPoint * >(argp1);
5719 arg2 = obj1;
5720 {
5721 result = (bool)wxPoint___eq__(arg1,arg2);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 {
5725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5726 }
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5734 PyObject *resultobj = 0;
5735 wxPoint *arg1 = (wxPoint *) 0 ;
5736 PyObject *arg2 = (PyObject *) 0 ;
5737 bool result;
5738 void *argp1 = 0 ;
5739 int res1 = 0 ;
5740 PyObject * obj0 = 0 ;
5741 PyObject * obj1 = 0 ;
5742 char * kwnames[] = {
5743 (char *) "self",(char *) "other", NULL
5744 };
5745
5746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5748 if (!SWIG_IsOK(res1)) {
5749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5750 }
5751 arg1 = reinterpret_cast< wxPoint * >(argp1);
5752 arg2 = obj1;
5753 {
5754 result = (bool)wxPoint___ne__(arg1,arg2);
5755 if (PyErr_Occurred()) SWIG_fail;
5756 }
5757 {
5758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5759 }
5760 return resultobj;
5761 fail:
5762 return NULL;
5763 }
5764
5765
5766 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5767 PyObject *resultobj = 0;
5768 wxPoint *arg1 = (wxPoint *) 0 ;
5769 wxPoint *arg2 = 0 ;
5770 wxPoint result;
5771 void *argp1 = 0 ;
5772 int res1 = 0 ;
5773 wxPoint temp2 ;
5774 PyObject * obj0 = 0 ;
5775 PyObject * obj1 = 0 ;
5776 char * kwnames[] = {
5777 (char *) "self",(char *) "pt", NULL
5778 };
5779
5780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5782 if (!SWIG_IsOK(res1)) {
5783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5784 }
5785 arg1 = reinterpret_cast< wxPoint * >(argp1);
5786 {
5787 arg2 = &temp2;
5788 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5789 }
5790 {
5791 PyThreadState* __tstate = wxPyBeginAllowThreads();
5792 result = (arg1)->operator +((wxPoint const &)*arg2);
5793 wxPyEndAllowThreads(__tstate);
5794 if (PyErr_Occurred()) SWIG_fail;
5795 }
5796 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5797 return resultobj;
5798 fail:
5799 return NULL;
5800 }
5801
5802
5803 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5804 PyObject *resultobj = 0;
5805 wxPoint *arg1 = (wxPoint *) 0 ;
5806 wxPoint *arg2 = 0 ;
5807 wxPoint result;
5808 void *argp1 = 0 ;
5809 int res1 = 0 ;
5810 wxPoint temp2 ;
5811 PyObject * obj0 = 0 ;
5812 PyObject * obj1 = 0 ;
5813 char * kwnames[] = {
5814 (char *) "self",(char *) "pt", NULL
5815 };
5816
5817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5819 if (!SWIG_IsOK(res1)) {
5820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5821 }
5822 arg1 = reinterpret_cast< wxPoint * >(argp1);
5823 {
5824 arg2 = &temp2;
5825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5826 }
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 result = (arg1)->operator -((wxPoint const &)*arg2);
5830 wxPyEndAllowThreads(__tstate);
5831 if (PyErr_Occurred()) SWIG_fail;
5832 }
5833 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5834 return resultobj;
5835 fail:
5836 return NULL;
5837 }
5838
5839
5840 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5841 PyObject *resultobj = 0;
5842 wxPoint *arg1 = (wxPoint *) 0 ;
5843 wxPoint *arg2 = 0 ;
5844 wxPoint *result = 0 ;
5845 void *argp1 = 0 ;
5846 int res1 = 0 ;
5847 wxPoint temp2 ;
5848 PyObject * obj0 = 0 ;
5849 PyObject * obj1 = 0 ;
5850 char * kwnames[] = {
5851 (char *) "self",(char *) "pt", NULL
5852 };
5853
5854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5856 if (!SWIG_IsOK(res1)) {
5857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5858 }
5859 arg1 = reinterpret_cast< wxPoint * >(argp1);
5860 {
5861 arg2 = &temp2;
5862 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5863 }
5864 {
5865 PyThreadState* __tstate = wxPyBeginAllowThreads();
5866 {
5867 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5868 result = (wxPoint *) &_result_ref;
5869 }
5870 wxPyEndAllowThreads(__tstate);
5871 if (PyErr_Occurred()) SWIG_fail;
5872 }
5873 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5874 return resultobj;
5875 fail:
5876 return NULL;
5877 }
5878
5879
5880 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5881 PyObject *resultobj = 0;
5882 wxPoint *arg1 = (wxPoint *) 0 ;
5883 wxPoint *arg2 = 0 ;
5884 wxPoint *result = 0 ;
5885 void *argp1 = 0 ;
5886 int res1 = 0 ;
5887 wxPoint temp2 ;
5888 PyObject * obj0 = 0 ;
5889 PyObject * obj1 = 0 ;
5890 char * kwnames[] = {
5891 (char *) "self",(char *) "pt", NULL
5892 };
5893
5894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5896 if (!SWIG_IsOK(res1)) {
5897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5898 }
5899 arg1 = reinterpret_cast< wxPoint * >(argp1);
5900 {
5901 arg2 = &temp2;
5902 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5903 }
5904 {
5905 PyThreadState* __tstate = wxPyBeginAllowThreads();
5906 {
5907 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5908 result = (wxPoint *) &_result_ref;
5909 }
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 long arg2 ;
5924 long arg3 ;
5925 void *argp1 = 0 ;
5926 int res1 = 0 ;
5927 long val2 ;
5928 int ecode2 = 0 ;
5929 long val3 ;
5930 int ecode3 = 0 ;
5931 PyObject * obj0 = 0 ;
5932 PyObject * obj1 = 0 ;
5933 PyObject * obj2 = 0 ;
5934 char * kwnames[] = {
5935 (char *) "self",(char *) "x",(char *) "y", NULL
5936 };
5937
5938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5940 if (!SWIG_IsOK(res1)) {
5941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5942 }
5943 arg1 = reinterpret_cast< wxPoint * >(argp1);
5944 ecode2 = SWIG_AsVal_long(obj1, &val2);
5945 if (!SWIG_IsOK(ecode2)) {
5946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5947 }
5948 arg2 = static_cast< long >(val2);
5949 ecode3 = SWIG_AsVal_long(obj2, &val3);
5950 if (!SWIG_IsOK(ecode3)) {
5951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5952 }
5953 arg3 = static_cast< long >(val3);
5954 {
5955 PyThreadState* __tstate = wxPyBeginAllowThreads();
5956 wxPoint_Set(arg1,arg2,arg3);
5957 wxPyEndAllowThreads(__tstate);
5958 if (PyErr_Occurred()) SWIG_fail;
5959 }
5960 resultobj = SWIG_Py_Void();
5961 return resultobj;
5962 fail:
5963 return NULL;
5964 }
5965
5966
5967 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5968 PyObject *resultobj = 0;
5969 wxPoint *arg1 = (wxPoint *) 0 ;
5970 PyObject *result = 0 ;
5971 void *argp1 = 0 ;
5972 int res1 = 0 ;
5973 PyObject *swig_obj[1] ;
5974
5975 if (!args) SWIG_fail;
5976 swig_obj[0] = args;
5977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5978 if (!SWIG_IsOK(res1)) {
5979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5980 }
5981 arg1 = reinterpret_cast< wxPoint * >(argp1);
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 result = (PyObject *)wxPoint_Get(arg1);
5985 wxPyEndAllowThreads(__tstate);
5986 if (PyErr_Occurred()) SWIG_fail;
5987 }
5988 resultobj = result;
5989 return resultobj;
5990 fail:
5991 return NULL;
5992 }
5993
5994
5995 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5996 PyObject *obj;
5997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5998 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5999 return SWIG_Py_Void();
6000 }
6001
6002 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6003 return SWIG_Python_InitShadowInstance(args);
6004 }
6005
6006 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj = 0;
6008 int arg1 = (int) 0 ;
6009 int arg2 = (int) 0 ;
6010 int arg3 = (int) 0 ;
6011 int arg4 = (int) 0 ;
6012 wxRect *result = 0 ;
6013 int val1 ;
6014 int ecode1 = 0 ;
6015 int val2 ;
6016 int ecode2 = 0 ;
6017 int val3 ;
6018 int ecode3 = 0 ;
6019 int val4 ;
6020 int ecode4 = 0 ;
6021 PyObject * obj0 = 0 ;
6022 PyObject * obj1 = 0 ;
6023 PyObject * obj2 = 0 ;
6024 PyObject * obj3 = 0 ;
6025 char * kwnames[] = {
6026 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6027 };
6028
6029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6030 if (obj0) {
6031 ecode1 = SWIG_AsVal_int(obj0, &val1);
6032 if (!SWIG_IsOK(ecode1)) {
6033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6034 }
6035 arg1 = static_cast< int >(val1);
6036 }
6037 if (obj1) {
6038 ecode2 = SWIG_AsVal_int(obj1, &val2);
6039 if (!SWIG_IsOK(ecode2)) {
6040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6041 }
6042 arg2 = static_cast< int >(val2);
6043 }
6044 if (obj2) {
6045 ecode3 = SWIG_AsVal_int(obj2, &val3);
6046 if (!SWIG_IsOK(ecode3)) {
6047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6048 }
6049 arg3 = static_cast< int >(val3);
6050 }
6051 if (obj3) {
6052 ecode4 = SWIG_AsVal_int(obj3, &val4);
6053 if (!SWIG_IsOK(ecode4)) {
6054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6055 }
6056 arg4 = static_cast< int >(val4);
6057 }
6058 {
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6061 wxPyEndAllowThreads(__tstate);
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 wxPoint *arg1 = 0 ;
6074 wxPoint *arg2 = 0 ;
6075 wxRect *result = 0 ;
6076 wxPoint temp1 ;
6077 wxPoint temp2 ;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 char * kwnames[] = {
6081 (char *) "topLeft",(char *) "bottomRight", NULL
6082 };
6083
6084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6085 {
6086 arg1 = &temp1;
6087 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6088 }
6089 {
6090 arg2 = &temp2;
6091 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6092 }
6093 {
6094 PyThreadState* __tstate = wxPyBeginAllowThreads();
6095 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6096 wxPyEndAllowThreads(__tstate);
6097 if (PyErr_Occurred()) SWIG_fail;
6098 }
6099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6100 return resultobj;
6101 fail:
6102 return NULL;
6103 }
6104
6105
6106 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6107 PyObject *resultobj = 0;
6108 wxPoint *arg1 = 0 ;
6109 wxSize *arg2 = 0 ;
6110 wxRect *result = 0 ;
6111 wxPoint temp1 ;
6112 wxSize temp2 ;
6113 PyObject * obj0 = 0 ;
6114 PyObject * obj1 = 0 ;
6115 char * kwnames[] = {
6116 (char *) "pos",(char *) "size", NULL
6117 };
6118
6119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6120 {
6121 arg1 = &temp1;
6122 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6123 }
6124 {
6125 arg2 = &temp2;
6126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6127 }
6128 {
6129 PyThreadState* __tstate = wxPyBeginAllowThreads();
6130 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6131 wxPyEndAllowThreads(__tstate);
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6142 PyObject *resultobj = 0;
6143 wxSize *arg1 = 0 ;
6144 wxRect *result = 0 ;
6145 wxSize temp1 ;
6146 PyObject * obj0 = 0 ;
6147 char * kwnames[] = {
6148 (char *) "size", NULL
6149 };
6150
6151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6152 {
6153 arg1 = &temp1;
6154 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6155 }
6156 {
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6159 wxPyEndAllowThreads(__tstate);
6160 if (PyErr_Occurred()) SWIG_fail;
6161 }
6162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6163 return resultobj;
6164 fail:
6165 return NULL;
6166 }
6167
6168
6169 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6170 PyObject *resultobj = 0;
6171 wxRect *arg1 = (wxRect *) 0 ;
6172 void *argp1 = 0 ;
6173 int res1 = 0 ;
6174 PyObject *swig_obj[1] ;
6175
6176 if (!args) SWIG_fail;
6177 swig_obj[0] = args;
6178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6179 if (!SWIG_IsOK(res1)) {
6180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6181 }
6182 arg1 = reinterpret_cast< wxRect * >(argp1);
6183 {
6184 PyThreadState* __tstate = wxPyBeginAllowThreads();
6185 delete arg1;
6186
6187 wxPyEndAllowThreads(__tstate);
6188 if (PyErr_Occurred()) SWIG_fail;
6189 }
6190 resultobj = SWIG_Py_Void();
6191 return resultobj;
6192 fail:
6193 return NULL;
6194 }
6195
6196
6197 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6198 PyObject *resultobj = 0;
6199 wxRect *arg1 = (wxRect *) 0 ;
6200 int result;
6201 void *argp1 = 0 ;
6202 int res1 = 0 ;
6203 PyObject *swig_obj[1] ;
6204
6205 if (!args) SWIG_fail;
6206 swig_obj[0] = args;
6207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6208 if (!SWIG_IsOK(res1)) {
6209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6210 }
6211 arg1 = reinterpret_cast< wxRect * >(argp1);
6212 {
6213 PyThreadState* __tstate = wxPyBeginAllowThreads();
6214 result = (int)((wxRect const *)arg1)->GetX();
6215 wxPyEndAllowThreads(__tstate);
6216 if (PyErr_Occurred()) SWIG_fail;
6217 }
6218 resultobj = SWIG_From_int(static_cast< int >(result));
6219 return resultobj;
6220 fail:
6221 return NULL;
6222 }
6223
6224
6225 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6226 PyObject *resultobj = 0;
6227 wxRect *arg1 = (wxRect *) 0 ;
6228 int arg2 ;
6229 void *argp1 = 0 ;
6230 int res1 = 0 ;
6231 int val2 ;
6232 int ecode2 = 0 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char * kwnames[] = {
6236 (char *) "self",(char *) "x", NULL
6237 };
6238
6239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6241 if (!SWIG_IsOK(res1)) {
6242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6243 }
6244 arg1 = reinterpret_cast< wxRect * >(argp1);
6245 ecode2 = SWIG_AsVal_int(obj1, &val2);
6246 if (!SWIG_IsOK(ecode2)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6248 }
6249 arg2 = static_cast< int >(val2);
6250 {
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 (arg1)->SetX(arg2);
6253 wxPyEndAllowThreads(__tstate);
6254 if (PyErr_Occurred()) SWIG_fail;
6255 }
6256 resultobj = SWIG_Py_Void();
6257 return resultobj;
6258 fail:
6259 return NULL;
6260 }
6261
6262
6263 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6264 PyObject *resultobj = 0;
6265 wxRect *arg1 = (wxRect *) 0 ;
6266 int result;
6267 void *argp1 = 0 ;
6268 int res1 = 0 ;
6269 PyObject *swig_obj[1] ;
6270
6271 if (!args) SWIG_fail;
6272 swig_obj[0] = args;
6273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6274 if (!SWIG_IsOK(res1)) {
6275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6276 }
6277 arg1 = reinterpret_cast< wxRect * >(argp1);
6278 {
6279 PyThreadState* __tstate = wxPyBeginAllowThreads();
6280 result = (int)(arg1)->GetY();
6281 wxPyEndAllowThreads(__tstate);
6282 if (PyErr_Occurred()) SWIG_fail;
6283 }
6284 resultobj = SWIG_From_int(static_cast< int >(result));
6285 return resultobj;
6286 fail:
6287 return NULL;
6288 }
6289
6290
6291 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj = 0;
6293 wxRect *arg1 = (wxRect *) 0 ;
6294 int arg2 ;
6295 void *argp1 = 0 ;
6296 int res1 = 0 ;
6297 int val2 ;
6298 int ecode2 = 0 ;
6299 PyObject * obj0 = 0 ;
6300 PyObject * obj1 = 0 ;
6301 char * kwnames[] = {
6302 (char *) "self",(char *) "y", NULL
6303 };
6304
6305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6307 if (!SWIG_IsOK(res1)) {
6308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6309 }
6310 arg1 = reinterpret_cast< wxRect * >(argp1);
6311 ecode2 = SWIG_AsVal_int(obj1, &val2);
6312 if (!SWIG_IsOK(ecode2)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6314 }
6315 arg2 = static_cast< int >(val2);
6316 {
6317 PyThreadState* __tstate = wxPyBeginAllowThreads();
6318 (arg1)->SetY(arg2);
6319 wxPyEndAllowThreads(__tstate);
6320 if (PyErr_Occurred()) SWIG_fail;
6321 }
6322 resultobj = SWIG_Py_Void();
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6330 PyObject *resultobj = 0;
6331 wxRect *arg1 = (wxRect *) 0 ;
6332 int result;
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, 0 | 0 );
6340 if (!SWIG_IsOK(res1)) {
6341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6342 }
6343 arg1 = reinterpret_cast< wxRect * >(argp1);
6344 {
6345 PyThreadState* __tstate = wxPyBeginAllowThreads();
6346 result = (int)((wxRect const *)arg1)->GetWidth();
6347 wxPyEndAllowThreads(__tstate);
6348 if (PyErr_Occurred()) SWIG_fail;
6349 }
6350 resultobj = SWIG_From_int(static_cast< int >(result));
6351 return resultobj;
6352 fail:
6353 return NULL;
6354 }
6355
6356
6357 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6358 PyObject *resultobj = 0;
6359 wxRect *arg1 = (wxRect *) 0 ;
6360 int arg2 ;
6361 void *argp1 = 0 ;
6362 int res1 = 0 ;
6363 int val2 ;
6364 int ecode2 = 0 ;
6365 PyObject * obj0 = 0 ;
6366 PyObject * obj1 = 0 ;
6367 char * kwnames[] = {
6368 (char *) "self",(char *) "w", NULL
6369 };
6370
6371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6373 if (!SWIG_IsOK(res1)) {
6374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6375 }
6376 arg1 = reinterpret_cast< wxRect * >(argp1);
6377 ecode2 = SWIG_AsVal_int(obj1, &val2);
6378 if (!SWIG_IsOK(ecode2)) {
6379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6380 }
6381 arg2 = static_cast< int >(val2);
6382 {
6383 PyThreadState* __tstate = wxPyBeginAllowThreads();
6384 (arg1)->SetWidth(arg2);
6385 wxPyEndAllowThreads(__tstate);
6386 if (PyErr_Occurred()) SWIG_fail;
6387 }
6388 resultobj = SWIG_Py_Void();
6389 return resultobj;
6390 fail:
6391 return NULL;
6392 }
6393
6394
6395 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6396 PyObject *resultobj = 0;
6397 wxRect *arg1 = (wxRect *) 0 ;
6398 int result;
6399 void *argp1 = 0 ;
6400 int res1 = 0 ;
6401 PyObject *swig_obj[1] ;
6402
6403 if (!args) SWIG_fail;
6404 swig_obj[0] = args;
6405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6408 }
6409 arg1 = reinterpret_cast< wxRect * >(argp1);
6410 {
6411 PyThreadState* __tstate = wxPyBeginAllowThreads();
6412 result = (int)((wxRect const *)arg1)->GetHeight();
6413 wxPyEndAllowThreads(__tstate);
6414 if (PyErr_Occurred()) SWIG_fail;
6415 }
6416 resultobj = SWIG_From_int(static_cast< int >(result));
6417 return resultobj;
6418 fail:
6419 return NULL;
6420 }
6421
6422
6423 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6424 PyObject *resultobj = 0;
6425 wxRect *arg1 = (wxRect *) 0 ;
6426 int arg2 ;
6427 void *argp1 = 0 ;
6428 int res1 = 0 ;
6429 int val2 ;
6430 int ecode2 = 0 ;
6431 PyObject * obj0 = 0 ;
6432 PyObject * obj1 = 0 ;
6433 char * kwnames[] = {
6434 (char *) "self",(char *) "h", NULL
6435 };
6436
6437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6439 if (!SWIG_IsOK(res1)) {
6440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6441 }
6442 arg1 = reinterpret_cast< wxRect * >(argp1);
6443 ecode2 = SWIG_AsVal_int(obj1, &val2);
6444 if (!SWIG_IsOK(ecode2)) {
6445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6446 }
6447 arg2 = static_cast< int >(val2);
6448 {
6449 PyThreadState* __tstate = wxPyBeginAllowThreads();
6450 (arg1)->SetHeight(arg2);
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_Py_Void();
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 wxPoint result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 {
6477 PyThreadState* __tstate = wxPyBeginAllowThreads();
6478 result = ((wxRect const *)arg1)->GetPosition();
6479 wxPyEndAllowThreads(__tstate);
6480 if (PyErr_Occurred()) SWIG_fail;
6481 }
6482 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6483 return resultobj;
6484 fail:
6485 return NULL;
6486 }
6487
6488
6489 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6490 PyObject *resultobj = 0;
6491 wxRect *arg1 = (wxRect *) 0 ;
6492 wxPoint *arg2 = 0 ;
6493 void *argp1 = 0 ;
6494 int res1 = 0 ;
6495 wxPoint temp2 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "p", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 {
6509 arg2 = &temp2;
6510 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6511 }
6512 {
6513 PyThreadState* __tstate = wxPyBeginAllowThreads();
6514 (arg1)->SetPosition((wxPoint const &)*arg2);
6515 wxPyEndAllowThreads(__tstate);
6516 if (PyErr_Occurred()) SWIG_fail;
6517 }
6518 resultobj = SWIG_Py_Void();
6519 return resultobj;
6520 fail:
6521 return NULL;
6522 }
6523
6524
6525 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6526 PyObject *resultobj = 0;
6527 wxRect *arg1 = (wxRect *) 0 ;
6528 wxSize result;
6529 void *argp1 = 0 ;
6530 int res1 = 0 ;
6531 PyObject *swig_obj[1] ;
6532
6533 if (!args) SWIG_fail;
6534 swig_obj[0] = args;
6535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6536 if (!SWIG_IsOK(res1)) {
6537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6538 }
6539 arg1 = reinterpret_cast< wxRect * >(argp1);
6540 {
6541 PyThreadState* __tstate = wxPyBeginAllowThreads();
6542 result = ((wxRect const *)arg1)->GetSize();
6543 wxPyEndAllowThreads(__tstate);
6544 if (PyErr_Occurred()) SWIG_fail;
6545 }
6546 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6547 return resultobj;
6548 fail:
6549 return NULL;
6550 }
6551
6552
6553 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6554 PyObject *resultobj = 0;
6555 wxRect *arg1 = (wxRect *) 0 ;
6556 wxSize *arg2 = 0 ;
6557 void *argp1 = 0 ;
6558 int res1 = 0 ;
6559 wxSize temp2 ;
6560 PyObject * obj0 = 0 ;
6561 PyObject * obj1 = 0 ;
6562 char * kwnames[] = {
6563 (char *) "self",(char *) "s", NULL
6564 };
6565
6566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6568 if (!SWIG_IsOK(res1)) {
6569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6570 }
6571 arg1 = reinterpret_cast< wxRect * >(argp1);
6572 {
6573 arg2 = &temp2;
6574 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6575 }
6576 {
6577 PyThreadState* __tstate = wxPyBeginAllowThreads();
6578 (arg1)->SetSize((wxSize const &)*arg2);
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 resultobj = SWIG_Py_Void();
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6590 PyObject *resultobj = 0;
6591 wxRect *arg1 = (wxRect *) 0 ;
6592 bool result;
6593 void *argp1 = 0 ;
6594 int res1 = 0 ;
6595 PyObject *swig_obj[1] ;
6596
6597 if (!args) SWIG_fail;
6598 swig_obj[0] = args;
6599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 {
6605 PyThreadState* __tstate = wxPyBeginAllowThreads();
6606 result = (bool)((wxRect const *)arg1)->IsEmpty();
6607 wxPyEndAllowThreads(__tstate);
6608 if (PyErr_Occurred()) SWIG_fail;
6609 }
6610 {
6611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6612 }
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6620 PyObject *resultobj = 0;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 wxPoint result;
6623 void *argp1 = 0 ;
6624 int res1 = 0 ;
6625 PyObject *swig_obj[1] ;
6626
6627 if (!args) SWIG_fail;
6628 swig_obj[0] = args;
6629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6630 if (!SWIG_IsOK(res1)) {
6631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6632 }
6633 arg1 = reinterpret_cast< wxRect * >(argp1);
6634 {
6635 PyThreadState* __tstate = wxPyBeginAllowThreads();
6636 result = ((wxRect const *)arg1)->GetTopLeft();
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj = 0;
6649 wxRect *arg1 = (wxRect *) 0 ;
6650 wxPoint *arg2 = 0 ;
6651 void *argp1 = 0 ;
6652 int res1 = 0 ;
6653 wxPoint temp2 ;
6654 PyObject * obj0 = 0 ;
6655 PyObject * obj1 = 0 ;
6656 char * kwnames[] = {
6657 (char *) "self",(char *) "p", NULL
6658 };
6659
6660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6662 if (!SWIG_IsOK(res1)) {
6663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6664 }
6665 arg1 = reinterpret_cast< wxRect * >(argp1);
6666 {
6667 arg2 = &temp2;
6668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6669 }
6670 {
6671 PyThreadState* __tstate = wxPyBeginAllowThreads();
6672 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 resultobj = SWIG_Py_Void();
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6684 PyObject *resultobj = 0;
6685 wxRect *arg1 = (wxRect *) 0 ;
6686 wxPoint result;
6687 void *argp1 = 0 ;
6688 int res1 = 0 ;
6689 PyObject *swig_obj[1] ;
6690
6691 if (!args) SWIG_fail;
6692 swig_obj[0] = args;
6693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6694 if (!SWIG_IsOK(res1)) {
6695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6696 }
6697 arg1 = reinterpret_cast< wxRect * >(argp1);
6698 {
6699 PyThreadState* __tstate = wxPyBeginAllowThreads();
6700 result = ((wxRect const *)arg1)->GetBottomRight();
6701 wxPyEndAllowThreads(__tstate);
6702 if (PyErr_Occurred()) SWIG_fail;
6703 }
6704 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6705 return resultobj;
6706 fail:
6707 return NULL;
6708 }
6709
6710
6711 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6712 PyObject *resultobj = 0;
6713 wxRect *arg1 = (wxRect *) 0 ;
6714 wxPoint *arg2 = 0 ;
6715 void *argp1 = 0 ;
6716 int res1 = 0 ;
6717 wxPoint temp2 ;
6718 PyObject * obj0 = 0 ;
6719 PyObject * obj1 = 0 ;
6720 char * kwnames[] = {
6721 (char *) "self",(char *) "p", NULL
6722 };
6723
6724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6726 if (!SWIG_IsOK(res1)) {
6727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6728 }
6729 arg1 = reinterpret_cast< wxRect * >(argp1);
6730 {
6731 arg2 = &temp2;
6732 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6733 }
6734 {
6735 PyThreadState* __tstate = wxPyBeginAllowThreads();
6736 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_Py_Void();
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6748 PyObject *resultobj = 0;
6749 wxRect *arg1 = (wxRect *) 0 ;
6750 int result;
6751 void *argp1 = 0 ;
6752 int res1 = 0 ;
6753 PyObject *swig_obj[1] ;
6754
6755 if (!args) SWIG_fail;
6756 swig_obj[0] = args;
6757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6758 if (!SWIG_IsOK(res1)) {
6759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6760 }
6761 arg1 = reinterpret_cast< wxRect * >(argp1);
6762 {
6763 PyThreadState* __tstate = wxPyBeginAllowThreads();
6764 result = (int)((wxRect const *)arg1)->GetLeft();
6765 wxPyEndAllowThreads(__tstate);
6766 if (PyErr_Occurred()) SWIG_fail;
6767 }
6768 resultobj = SWIG_From_int(static_cast< int >(result));
6769 return resultobj;
6770 fail:
6771 return NULL;
6772 }
6773
6774
6775 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6776 PyObject *resultobj = 0;
6777 wxRect *arg1 = (wxRect *) 0 ;
6778 int result;
6779 void *argp1 = 0 ;
6780 int res1 = 0 ;
6781 PyObject *swig_obj[1] ;
6782
6783 if (!args) SWIG_fail;
6784 swig_obj[0] = args;
6785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6786 if (!SWIG_IsOK(res1)) {
6787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6788 }
6789 arg1 = reinterpret_cast< wxRect * >(argp1);
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 result = (int)((wxRect const *)arg1)->GetTop();
6793 wxPyEndAllowThreads(__tstate);
6794 if (PyErr_Occurred()) SWIG_fail;
6795 }
6796 resultobj = SWIG_From_int(static_cast< int >(result));
6797 return resultobj;
6798 fail:
6799 return NULL;
6800 }
6801
6802
6803 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804 PyObject *resultobj = 0;
6805 wxRect *arg1 = (wxRect *) 0 ;
6806 int result;
6807 void *argp1 = 0 ;
6808 int res1 = 0 ;
6809 PyObject *swig_obj[1] ;
6810
6811 if (!args) SWIG_fail;
6812 swig_obj[0] = args;
6813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6814 if (!SWIG_IsOK(res1)) {
6815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6816 }
6817 arg1 = reinterpret_cast< wxRect * >(argp1);
6818 {
6819 PyThreadState* __tstate = wxPyBeginAllowThreads();
6820 result = (int)((wxRect const *)arg1)->GetBottom();
6821 wxPyEndAllowThreads(__tstate);
6822 if (PyErr_Occurred()) SWIG_fail;
6823 }
6824 resultobj = SWIG_From_int(static_cast< int >(result));
6825 return resultobj;
6826 fail:
6827 return NULL;
6828 }
6829
6830
6831 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6832 PyObject *resultobj = 0;
6833 wxRect *arg1 = (wxRect *) 0 ;
6834 int result;
6835 void *argp1 = 0 ;
6836 int res1 = 0 ;
6837 PyObject *swig_obj[1] ;
6838
6839 if (!args) SWIG_fail;
6840 swig_obj[0] = args;
6841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6842 if (!SWIG_IsOK(res1)) {
6843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6844 }
6845 arg1 = reinterpret_cast< wxRect * >(argp1);
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 result = (int)((wxRect const *)arg1)->GetRight();
6849 wxPyEndAllowThreads(__tstate);
6850 if (PyErr_Occurred()) SWIG_fail;
6851 }
6852 resultobj = SWIG_From_int(static_cast< int >(result));
6853 return resultobj;
6854 fail:
6855 return NULL;
6856 }
6857
6858
6859 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6860 PyObject *resultobj = 0;
6861 wxRect *arg1 = (wxRect *) 0 ;
6862 int arg2 ;
6863 void *argp1 = 0 ;
6864 int res1 = 0 ;
6865 int val2 ;
6866 int ecode2 = 0 ;
6867 PyObject * obj0 = 0 ;
6868 PyObject * obj1 = 0 ;
6869 char * kwnames[] = {
6870 (char *) "self",(char *) "left", NULL
6871 };
6872
6873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6875 if (!SWIG_IsOK(res1)) {
6876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6877 }
6878 arg1 = reinterpret_cast< wxRect * >(argp1);
6879 ecode2 = SWIG_AsVal_int(obj1, &val2);
6880 if (!SWIG_IsOK(ecode2)) {
6881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6882 }
6883 arg2 = static_cast< int >(val2);
6884 {
6885 PyThreadState* __tstate = wxPyBeginAllowThreads();
6886 (arg1)->SetLeft(arg2);
6887 wxPyEndAllowThreads(__tstate);
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 resultobj = SWIG_Py_Void();
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6898 PyObject *resultobj = 0;
6899 wxRect *arg1 = (wxRect *) 0 ;
6900 int arg2 ;
6901 void *argp1 = 0 ;
6902 int res1 = 0 ;
6903 int val2 ;
6904 int ecode2 = 0 ;
6905 PyObject * obj0 = 0 ;
6906 PyObject * obj1 = 0 ;
6907 char * kwnames[] = {
6908 (char *) "self",(char *) "right", NULL
6909 };
6910
6911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6913 if (!SWIG_IsOK(res1)) {
6914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6915 }
6916 arg1 = reinterpret_cast< wxRect * >(argp1);
6917 ecode2 = SWIG_AsVal_int(obj1, &val2);
6918 if (!SWIG_IsOK(ecode2)) {
6919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6920 }
6921 arg2 = static_cast< int >(val2);
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 (arg1)->SetRight(arg2);
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 resultobj = SWIG_Py_Void();
6929 return resultobj;
6930 fail:
6931 return NULL;
6932 }
6933
6934
6935 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6936 PyObject *resultobj = 0;
6937 wxRect *arg1 = (wxRect *) 0 ;
6938 int arg2 ;
6939 void *argp1 = 0 ;
6940 int res1 = 0 ;
6941 int val2 ;
6942 int ecode2 = 0 ;
6943 PyObject * obj0 = 0 ;
6944 PyObject * obj1 = 0 ;
6945 char * kwnames[] = {
6946 (char *) "self",(char *) "top", NULL
6947 };
6948
6949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",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_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 ecode2 = SWIG_AsVal_int(obj1, &val2);
6956 if (!SWIG_IsOK(ecode2)) {
6957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6958 }
6959 arg2 = static_cast< int >(val2);
6960 {
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 (arg1)->SetTop(arg2);
6963 wxPyEndAllowThreads(__tstate);
6964 if (PyErr_Occurred()) SWIG_fail;
6965 }
6966 resultobj = SWIG_Py_Void();
6967 return resultobj;
6968 fail:
6969 return NULL;
6970 }
6971
6972
6973 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6974 PyObject *resultobj = 0;
6975 wxRect *arg1 = (wxRect *) 0 ;
6976 int arg2 ;
6977 void *argp1 = 0 ;
6978 int res1 = 0 ;
6979 int val2 ;
6980 int ecode2 = 0 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char * kwnames[] = {
6984 (char *) "self",(char *) "bottom", NULL
6985 };
6986
6987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 ecode2 = SWIG_AsVal_int(obj1, &val2);
6994 if (!SWIG_IsOK(ecode2)) {
6995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6996 }
6997 arg2 = static_cast< int >(val2);
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 (arg1)->SetBottom(arg2);
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_Py_Void();
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj = 0;
7013 wxRect *arg1 = (wxRect *) 0 ;
7014 int arg2 ;
7015 int arg3 ;
7016 wxRect *result = 0 ;
7017 void *argp1 = 0 ;
7018 int res1 = 0 ;
7019 int val2 ;
7020 int ecode2 = 0 ;
7021 int val3 ;
7022 int ecode3 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 PyObject * obj2 = 0 ;
7026 char * kwnames[] = {
7027 (char *) "self",(char *) "dx",(char *) "dy", NULL
7028 };
7029
7030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7032 if (!SWIG_IsOK(res1)) {
7033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7034 }
7035 arg1 = reinterpret_cast< wxRect * >(argp1);
7036 ecode2 = SWIG_AsVal_int(obj1, &val2);
7037 if (!SWIG_IsOK(ecode2)) {
7038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7039 }
7040 arg2 = static_cast< int >(val2);
7041 ecode3 = SWIG_AsVal_int(obj2, &val3);
7042 if (!SWIG_IsOK(ecode3)) {
7043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7044 }
7045 arg3 = static_cast< int >(val3);
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 {
7049 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7050 result = (wxRect *) &_result_ref;
7051 }
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7056 return resultobj;
7057 fail:
7058 return NULL;
7059 }
7060
7061
7062 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7063 PyObject *resultobj = 0;
7064 wxRect *arg1 = (wxRect *) 0 ;
7065 int arg2 ;
7066 int arg3 ;
7067 wxRect *result = 0 ;
7068 void *argp1 = 0 ;
7069 int res1 = 0 ;
7070 int val2 ;
7071 int ecode2 = 0 ;
7072 int val3 ;
7073 int ecode3 = 0 ;
7074 PyObject * obj0 = 0 ;
7075 PyObject * obj1 = 0 ;
7076 PyObject * obj2 = 0 ;
7077 char * kwnames[] = {
7078 (char *) "self",(char *) "dx",(char *) "dy", NULL
7079 };
7080
7081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7083 if (!SWIG_IsOK(res1)) {
7084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7085 }
7086 arg1 = reinterpret_cast< wxRect * >(argp1);
7087 ecode2 = SWIG_AsVal_int(obj1, &val2);
7088 if (!SWIG_IsOK(ecode2)) {
7089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7090 }
7091 arg2 = static_cast< int >(val2);
7092 ecode3 = SWIG_AsVal_int(obj2, &val3);
7093 if (!SWIG_IsOK(ecode3)) {
7094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7095 }
7096 arg3 = static_cast< int >(val3);
7097 {
7098 PyThreadState* __tstate = wxPyBeginAllowThreads();
7099 {
7100 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7101 result = (wxRect *) &_result_ref;
7102 }
7103 wxPyEndAllowThreads(__tstate);
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj = 0;
7115 wxRect *arg1 = (wxRect *) 0 ;
7116 int arg2 ;
7117 int arg3 ;
7118 void *argp1 = 0 ;
7119 int res1 = 0 ;
7120 int val2 ;
7121 int ecode2 = 0 ;
7122 int val3 ;
7123 int ecode3 = 0 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 PyObject * obj2 = 0 ;
7127 char * kwnames[] = {
7128 (char *) "self",(char *) "dx",(char *) "dy", NULL
7129 };
7130
7131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7133 if (!SWIG_IsOK(res1)) {
7134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7135 }
7136 arg1 = reinterpret_cast< wxRect * >(argp1);
7137 ecode2 = SWIG_AsVal_int(obj1, &val2);
7138 if (!SWIG_IsOK(ecode2)) {
7139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7140 }
7141 arg2 = static_cast< int >(val2);
7142 ecode3 = SWIG_AsVal_int(obj2, &val3);
7143 if (!SWIG_IsOK(ecode3)) {
7144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7145 }
7146 arg3 = static_cast< int >(val3);
7147 {
7148 PyThreadState* __tstate = wxPyBeginAllowThreads();
7149 (arg1)->Offset(arg2,arg3);
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 resultobj = SWIG_Py_Void();
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7161 PyObject *resultobj = 0;
7162 wxRect *arg1 = (wxRect *) 0 ;
7163 wxPoint *arg2 = 0 ;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 wxPoint temp2 ;
7167 PyObject * obj0 = 0 ;
7168 PyObject * obj1 = 0 ;
7169 char * kwnames[] = {
7170 (char *) "self",(char *) "pt", NULL
7171 };
7172
7173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7175 if (!SWIG_IsOK(res1)) {
7176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7177 }
7178 arg1 = reinterpret_cast< wxRect * >(argp1);
7179 {
7180 arg2 = &temp2;
7181 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7182 }
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 (arg1)->Offset((wxPoint const &)*arg2);
7186 wxPyEndAllowThreads(__tstate);
7187 if (PyErr_Occurred()) SWIG_fail;
7188 }
7189 resultobj = SWIG_Py_Void();
7190 return resultobj;
7191 fail:
7192 return NULL;
7193 }
7194
7195
7196 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj = 0;
7198 wxRect *arg1 = (wxRect *) 0 ;
7199 wxRect *arg2 = 0 ;
7200 wxRect result;
7201 void *argp1 = 0 ;
7202 int res1 = 0 ;
7203 wxRect temp2 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 char * kwnames[] = {
7207 (char *) "self",(char *) "rect", NULL
7208 };
7209
7210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7212 if (!SWIG_IsOK(res1)) {
7213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7214 }
7215 arg1 = reinterpret_cast< wxRect * >(argp1);
7216 {
7217 arg2 = &temp2;
7218 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7219 }
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (arg1)->Intersect((wxRect const &)*arg2);
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj = 0;
7235 wxRect *arg1 = (wxRect *) 0 ;
7236 wxRect *arg2 = 0 ;
7237 wxRect result;
7238 void *argp1 = 0 ;
7239 int res1 = 0 ;
7240 wxRect temp2 ;
7241 PyObject * obj0 = 0 ;
7242 PyObject * obj1 = 0 ;
7243 char * kwnames[] = {
7244 (char *) "self",(char *) "rect", NULL
7245 };
7246
7247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7249 if (!SWIG_IsOK(res1)) {
7250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7251 }
7252 arg1 = reinterpret_cast< wxRect * >(argp1);
7253 {
7254 arg2 = &temp2;
7255 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7256 }
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 result = (arg1)->Union((wxRect const &)*arg2);
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj = 0;
7272 wxRect *arg1 = (wxRect *) 0 ;
7273 wxRect *arg2 = 0 ;
7274 wxRect result;
7275 void *argp1 = 0 ;
7276 int res1 = 0 ;
7277 wxRect temp2 ;
7278 PyObject * obj0 = 0 ;
7279 PyObject * obj1 = 0 ;
7280 char * kwnames[] = {
7281 (char *) "self",(char *) "rect", NULL
7282 };
7283
7284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7286 if (!SWIG_IsOK(res1)) {
7287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7288 }
7289 arg1 = reinterpret_cast< wxRect * >(argp1);
7290 {
7291 arg2 = &temp2;
7292 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7293 }
7294 {
7295 PyThreadState* __tstate = wxPyBeginAllowThreads();
7296 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7297 wxPyEndAllowThreads(__tstate);
7298 if (PyErr_Occurred()) SWIG_fail;
7299 }
7300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7301 return resultobj;
7302 fail:
7303 return NULL;
7304 }
7305
7306
7307 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj = 0;
7309 wxRect *arg1 = (wxRect *) 0 ;
7310 wxRect *arg2 = 0 ;
7311 wxRect *result = 0 ;
7312 void *argp1 = 0 ;
7313 int res1 = 0 ;
7314 wxRect temp2 ;
7315 PyObject * obj0 = 0 ;
7316 PyObject * obj1 = 0 ;
7317 char * kwnames[] = {
7318 (char *) "self",(char *) "rect", NULL
7319 };
7320
7321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7323 if (!SWIG_IsOK(res1)) {
7324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7325 }
7326 arg1 = reinterpret_cast< wxRect * >(argp1);
7327 {
7328 arg2 = &temp2;
7329 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7330 }
7331 {
7332 PyThreadState* __tstate = wxPyBeginAllowThreads();
7333 {
7334 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7335 result = (wxRect *) &_result_ref;
7336 }
7337 wxPyEndAllowThreads(__tstate);
7338 if (PyErr_Occurred()) SWIG_fail;
7339 }
7340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7341 return resultobj;
7342 fail:
7343 return NULL;
7344 }
7345
7346
7347 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7348 PyObject *resultobj = 0;
7349 wxRect *arg1 = (wxRect *) 0 ;
7350 PyObject *arg2 = (PyObject *) 0 ;
7351 bool result;
7352 void *argp1 = 0 ;
7353 int res1 = 0 ;
7354 PyObject * obj0 = 0 ;
7355 PyObject * obj1 = 0 ;
7356 char * kwnames[] = {
7357 (char *) "self",(char *) "other", NULL
7358 };
7359
7360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7362 if (!SWIG_IsOK(res1)) {
7363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7364 }
7365 arg1 = reinterpret_cast< wxRect * >(argp1);
7366 arg2 = obj1;
7367 {
7368 result = (bool)wxRect___eq__(arg1,arg2);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 {
7372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7373 }
7374 return resultobj;
7375 fail:
7376 return NULL;
7377 }
7378
7379
7380 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7381 PyObject *resultobj = 0;
7382 wxRect *arg1 = (wxRect *) 0 ;
7383 PyObject *arg2 = (PyObject *) 0 ;
7384 bool result;
7385 void *argp1 = 0 ;
7386 int res1 = 0 ;
7387 PyObject * obj0 = 0 ;
7388 PyObject * obj1 = 0 ;
7389 char * kwnames[] = {
7390 (char *) "self",(char *) "other", NULL
7391 };
7392
7393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7395 if (!SWIG_IsOK(res1)) {
7396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7397 }
7398 arg1 = reinterpret_cast< wxRect * >(argp1);
7399 arg2 = obj1;
7400 {
7401 result = (bool)wxRect___ne__(arg1,arg2);
7402 if (PyErr_Occurred()) SWIG_fail;
7403 }
7404 {
7405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7406 }
7407 return resultobj;
7408 fail:
7409 return NULL;
7410 }
7411
7412
7413 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7414 PyObject *resultobj = 0;
7415 wxRect *arg1 = (wxRect *) 0 ;
7416 int arg2 ;
7417 int arg3 ;
7418 bool result;
7419 void *argp1 = 0 ;
7420 int res1 = 0 ;
7421 int val2 ;
7422 int ecode2 = 0 ;
7423 int val3 ;
7424 int ecode3 = 0 ;
7425 PyObject * obj0 = 0 ;
7426 PyObject * obj1 = 0 ;
7427 PyObject * obj2 = 0 ;
7428 char * kwnames[] = {
7429 (char *) "self",(char *) "x",(char *) "y", NULL
7430 };
7431
7432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7434 if (!SWIG_IsOK(res1)) {
7435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7436 }
7437 arg1 = reinterpret_cast< wxRect * >(argp1);
7438 ecode2 = SWIG_AsVal_int(obj1, &val2);
7439 if (!SWIG_IsOK(ecode2)) {
7440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7441 }
7442 arg2 = static_cast< int >(val2);
7443 ecode3 = SWIG_AsVal_int(obj2, &val3);
7444 if (!SWIG_IsOK(ecode3)) {
7445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7446 }
7447 arg3 = static_cast< int >(val3);
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7451 wxPyEndAllowThreads(__tstate);
7452 if (PyErr_Occurred()) SWIG_fail;
7453 }
7454 {
7455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7456 }
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 wxPoint *arg2 = 0 ;
7467 bool result;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 wxPoint temp2 ;
7471 PyObject * obj0 = 0 ;
7472 PyObject * obj1 = 0 ;
7473 char * kwnames[] = {
7474 (char *) "self",(char *) "pt", NULL
7475 };
7476
7477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7479 if (!SWIG_IsOK(res1)) {
7480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7481 }
7482 arg1 = reinterpret_cast< wxRect * >(argp1);
7483 {
7484 arg2 = &temp2;
7485 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7486 }
7487 {
7488 PyThreadState* __tstate = wxPyBeginAllowThreads();
7489 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7490 wxPyEndAllowThreads(__tstate);
7491 if (PyErr_Occurred()) SWIG_fail;
7492 }
7493 {
7494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7495 }
7496 return resultobj;
7497 fail:
7498 return NULL;
7499 }
7500
7501
7502 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7503 PyObject *resultobj = 0;
7504 wxRect *arg1 = (wxRect *) 0 ;
7505 wxRect *arg2 = 0 ;
7506 bool result;
7507 void *argp1 = 0 ;
7508 int res1 = 0 ;
7509 wxRect temp2 ;
7510 PyObject * obj0 = 0 ;
7511 PyObject * obj1 = 0 ;
7512 char * kwnames[] = {
7513 (char *) "self",(char *) "rect", NULL
7514 };
7515
7516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7518 if (!SWIG_IsOK(res1)) {
7519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7520 }
7521 arg1 = reinterpret_cast< wxRect * >(argp1);
7522 {
7523 arg2 = &temp2;
7524 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7525 }
7526 {
7527 PyThreadState* __tstate = wxPyBeginAllowThreads();
7528 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7529 wxPyEndAllowThreads(__tstate);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 {
7533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7534 }
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj = 0;
7543 wxRect *arg1 = (wxRect *) 0 ;
7544 wxRect *arg2 = 0 ;
7545 int arg3 = (int) wxBOTH ;
7546 wxRect result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 wxRect temp2 ;
7550 int val3 ;
7551 int ecode3 = 0 ;
7552 PyObject * obj0 = 0 ;
7553 PyObject * obj1 = 0 ;
7554 PyObject * obj2 = 0 ;
7555 char * kwnames[] = {
7556 (char *) "self",(char *) "r",(char *) "dir", NULL
7557 };
7558
7559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7563 }
7564 arg1 = reinterpret_cast< wxRect * >(argp1);
7565 {
7566 arg2 = &temp2;
7567 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7568 }
7569 if (obj2) {
7570 ecode3 = SWIG_AsVal_int(obj2, &val3);
7571 if (!SWIG_IsOK(ecode3)) {
7572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7573 }
7574 arg3 = static_cast< int >(val3);
7575 }
7576 {
7577 PyThreadState* __tstate = wxPyBeginAllowThreads();
7578 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7579 wxPyEndAllowThreads(__tstate);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7590 PyObject *resultobj = 0;
7591 wxRect *arg1 = (wxRect *) 0 ;
7592 int arg2 ;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 int val2 ;
7596 int ecode2 = 0 ;
7597 PyObject *swig_obj[2] ;
7598
7599 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7601 if (!SWIG_IsOK(res1)) {
7602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7603 }
7604 arg1 = reinterpret_cast< wxRect * >(argp1);
7605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7606 if (!SWIG_IsOK(ecode2)) {
7607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7608 }
7609 arg2 = static_cast< int >(val2);
7610 if (arg1) (arg1)->x = arg2;
7611
7612 resultobj = SWIG_Py_Void();
7613 return resultobj;
7614 fail:
7615 return NULL;
7616 }
7617
7618
7619 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7620 PyObject *resultobj = 0;
7621 wxRect *arg1 = (wxRect *) 0 ;
7622 int result;
7623 void *argp1 = 0 ;
7624 int res1 = 0 ;
7625 PyObject *swig_obj[1] ;
7626
7627 if (!args) SWIG_fail;
7628 swig_obj[0] = args;
7629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7630 if (!SWIG_IsOK(res1)) {
7631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7632 }
7633 arg1 = reinterpret_cast< wxRect * >(argp1);
7634 result = (int) ((arg1)->x);
7635 resultobj = SWIG_From_int(static_cast< int >(result));
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7643 PyObject *resultobj = 0;
7644 wxRect *arg1 = (wxRect *) 0 ;
7645 int arg2 ;
7646 void *argp1 = 0 ;
7647 int res1 = 0 ;
7648 int val2 ;
7649 int ecode2 = 0 ;
7650 PyObject *swig_obj[2] ;
7651
7652 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7654 if (!SWIG_IsOK(res1)) {
7655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7656 }
7657 arg1 = reinterpret_cast< wxRect * >(argp1);
7658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7659 if (!SWIG_IsOK(ecode2)) {
7660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7661 }
7662 arg2 = static_cast< int >(val2);
7663 if (arg1) (arg1)->y = arg2;
7664
7665 resultobj = SWIG_Py_Void();
7666 return resultobj;
7667 fail:
7668 return NULL;
7669 }
7670
7671
7672 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7673 PyObject *resultobj = 0;
7674 wxRect *arg1 = (wxRect *) 0 ;
7675 int result;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 PyObject *swig_obj[1] ;
7679
7680 if (!args) SWIG_fail;
7681 swig_obj[0] = args;
7682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7683 if (!SWIG_IsOK(res1)) {
7684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7685 }
7686 arg1 = reinterpret_cast< wxRect * >(argp1);
7687 result = (int) ((arg1)->y);
7688 resultobj = SWIG_From_int(static_cast< int >(result));
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7696 PyObject *resultobj = 0;
7697 wxRect *arg1 = (wxRect *) 0 ;
7698 int arg2 ;
7699 void *argp1 = 0 ;
7700 int res1 = 0 ;
7701 int val2 ;
7702 int ecode2 = 0 ;
7703 PyObject *swig_obj[2] ;
7704
7705 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7707 if (!SWIG_IsOK(res1)) {
7708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7709 }
7710 arg1 = reinterpret_cast< wxRect * >(argp1);
7711 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7712 if (!SWIG_IsOK(ecode2)) {
7713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7714 }
7715 arg2 = static_cast< int >(val2);
7716 if (arg1) (arg1)->width = arg2;
7717
7718 resultobj = SWIG_Py_Void();
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7726 PyObject *resultobj = 0;
7727 wxRect *arg1 = (wxRect *) 0 ;
7728 int result;
7729 void *argp1 = 0 ;
7730 int res1 = 0 ;
7731 PyObject *swig_obj[1] ;
7732
7733 if (!args) SWIG_fail;
7734 swig_obj[0] = args;
7735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7738 }
7739 arg1 = reinterpret_cast< wxRect * >(argp1);
7740 result = (int) ((arg1)->width);
7741 resultobj = SWIG_From_int(static_cast< int >(result));
7742 return resultobj;
7743 fail:
7744 return NULL;
7745 }
7746
7747
7748 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7749 PyObject *resultobj = 0;
7750 wxRect *arg1 = (wxRect *) 0 ;
7751 int arg2 ;
7752 void *argp1 = 0 ;
7753 int res1 = 0 ;
7754 int val2 ;
7755 int ecode2 = 0 ;
7756 PyObject *swig_obj[2] ;
7757
7758 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7760 if (!SWIG_IsOK(res1)) {
7761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7762 }
7763 arg1 = reinterpret_cast< wxRect * >(argp1);
7764 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7765 if (!SWIG_IsOK(ecode2)) {
7766 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7767 }
7768 arg2 = static_cast< int >(val2);
7769 if (arg1) (arg1)->height = arg2;
7770
7771 resultobj = SWIG_Py_Void();
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7779 PyObject *resultobj = 0;
7780 wxRect *arg1 = (wxRect *) 0 ;
7781 int result;
7782 void *argp1 = 0 ;
7783 int res1 = 0 ;
7784 PyObject *swig_obj[1] ;
7785
7786 if (!args) SWIG_fail;
7787 swig_obj[0] = args;
7788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7789 if (!SWIG_IsOK(res1)) {
7790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7791 }
7792 arg1 = reinterpret_cast< wxRect * >(argp1);
7793 result = (int) ((arg1)->height);
7794 resultobj = SWIG_From_int(static_cast< int >(result));
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj = 0;
7803 wxRect *arg1 = (wxRect *) 0 ;
7804 int arg2 = (int) 0 ;
7805 int arg3 = (int) 0 ;
7806 int arg4 = (int) 0 ;
7807 int arg5 = (int) 0 ;
7808 void *argp1 = 0 ;
7809 int res1 = 0 ;
7810 int val2 ;
7811 int ecode2 = 0 ;
7812 int val3 ;
7813 int ecode3 = 0 ;
7814 int val4 ;
7815 int ecode4 = 0 ;
7816 int val5 ;
7817 int ecode5 = 0 ;
7818 PyObject * obj0 = 0 ;
7819 PyObject * obj1 = 0 ;
7820 PyObject * obj2 = 0 ;
7821 PyObject * obj3 = 0 ;
7822 PyObject * obj4 = 0 ;
7823 char * kwnames[] = {
7824 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7825 };
7826
7827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7829 if (!SWIG_IsOK(res1)) {
7830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7831 }
7832 arg1 = reinterpret_cast< wxRect * >(argp1);
7833 if (obj1) {
7834 ecode2 = SWIG_AsVal_int(obj1, &val2);
7835 if (!SWIG_IsOK(ecode2)) {
7836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7837 }
7838 arg2 = static_cast< int >(val2);
7839 }
7840 if (obj2) {
7841 ecode3 = SWIG_AsVal_int(obj2, &val3);
7842 if (!SWIG_IsOK(ecode3)) {
7843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7844 }
7845 arg3 = static_cast< int >(val3);
7846 }
7847 if (obj3) {
7848 ecode4 = SWIG_AsVal_int(obj3, &val4);
7849 if (!SWIG_IsOK(ecode4)) {
7850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7851 }
7852 arg4 = static_cast< int >(val4);
7853 }
7854 if (obj4) {
7855 ecode5 = SWIG_AsVal_int(obj4, &val5);
7856 if (!SWIG_IsOK(ecode5)) {
7857 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7858 }
7859 arg5 = static_cast< int >(val5);
7860 }
7861 {
7862 PyThreadState* __tstate = wxPyBeginAllowThreads();
7863 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7864 wxPyEndAllowThreads(__tstate);
7865 if (PyErr_Occurred()) SWIG_fail;
7866 }
7867 resultobj = SWIG_Py_Void();
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7875 PyObject *resultobj = 0;
7876 wxRect *arg1 = (wxRect *) 0 ;
7877 PyObject *result = 0 ;
7878 void *argp1 = 0 ;
7879 int res1 = 0 ;
7880 PyObject *swig_obj[1] ;
7881
7882 if (!args) SWIG_fail;
7883 swig_obj[0] = args;
7884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7885 if (!SWIG_IsOK(res1)) {
7886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7887 }
7888 arg1 = reinterpret_cast< wxRect * >(argp1);
7889 {
7890 PyThreadState* __tstate = wxPyBeginAllowThreads();
7891 result = (PyObject *)wxRect_Get(arg1);
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 resultobj = result;
7896 return resultobj;
7897 fail:
7898 return NULL;
7899 }
7900
7901
7902 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7903 PyObject *obj;
7904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7905 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7906 return SWIG_Py_Void();
7907 }
7908
7909 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7910 return SWIG_Python_InitShadowInstance(args);
7911 }
7912
7913 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7914 PyObject *resultobj = 0;
7915 wxRect *arg1 = (wxRect *) 0 ;
7916 wxRect *arg2 = (wxRect *) 0 ;
7917 PyObject *result = 0 ;
7918 void *argp1 = 0 ;
7919 int res1 = 0 ;
7920 void *argp2 = 0 ;
7921 int res2 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 char * kwnames[] = {
7925 (char *) "r1",(char *) "r2", NULL
7926 };
7927
7928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7935 if (!SWIG_IsOK(res2)) {
7936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7937 }
7938 arg2 = reinterpret_cast< wxRect * >(argp2);
7939 {
7940 if (!wxPyCheckForApp()) SWIG_fail;
7941 PyThreadState* __tstate = wxPyBeginAllowThreads();
7942 result = (PyObject *)wxIntersectRect(arg1,arg2);
7943 wxPyEndAllowThreads(__tstate);
7944 if (PyErr_Occurred()) SWIG_fail;
7945 }
7946 resultobj = result;
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7954 PyObject *resultobj = 0;
7955 double arg1 = (double) 0.0 ;
7956 double arg2 = (double) 0.0 ;
7957 wxPoint2D *result = 0 ;
7958 double val1 ;
7959 int ecode1 = 0 ;
7960 double val2 ;
7961 int ecode2 = 0 ;
7962 PyObject * obj0 = 0 ;
7963 PyObject * obj1 = 0 ;
7964 char * kwnames[] = {
7965 (char *) "x",(char *) "y", NULL
7966 };
7967
7968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7969 if (obj0) {
7970 ecode1 = SWIG_AsVal_double(obj0, &val1);
7971 if (!SWIG_IsOK(ecode1)) {
7972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7973 }
7974 arg1 = static_cast< double >(val1);
7975 }
7976 if (obj1) {
7977 ecode2 = SWIG_AsVal_double(obj1, &val2);
7978 if (!SWIG_IsOK(ecode2)) {
7979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7980 }
7981 arg2 = static_cast< double >(val2);
7982 }
7983 {
7984 PyThreadState* __tstate = wxPyBeginAllowThreads();
7985 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7986 wxPyEndAllowThreads(__tstate);
7987 if (PyErr_Occurred()) SWIG_fail;
7988 }
7989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7997 PyObject *resultobj = 0;
7998 wxPoint2D *arg1 = 0 ;
7999 wxPoint2D *result = 0 ;
8000 wxPoint2D temp1 ;
8001 PyObject * obj0 = 0 ;
8002 char * kwnames[] = {
8003 (char *) "pt", NULL
8004 };
8005
8006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8007 {
8008 arg1 = &temp1;
8009 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8025 PyObject *resultobj = 0;
8026 wxPoint *arg1 = 0 ;
8027 wxPoint2D *result = 0 ;
8028 wxPoint temp1 ;
8029 PyObject * obj0 = 0 ;
8030 char * kwnames[] = {
8031 (char *) "pt", NULL
8032 };
8033
8034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8035 {
8036 arg1 = &temp1;
8037 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8038 }
8039 {
8040 PyThreadState* __tstate = wxPyBeginAllowThreads();
8041 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8053 PyObject *resultobj = 0;
8054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8055 int *arg2 = (int *) 0 ;
8056 int *arg3 = (int *) 0 ;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 int temp2 ;
8060 int res2 = SWIG_TMPOBJ ;
8061 int temp3 ;
8062 int res3 = SWIG_TMPOBJ ;
8063 PyObject *swig_obj[1] ;
8064
8065 arg2 = &temp2;
8066 arg3 = &temp3;
8067 if (!args) SWIG_fail;
8068 swig_obj[0] = args;
8069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8070 if (!SWIG_IsOK(res1)) {
8071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8072 }
8073 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 resultobj = SWIG_Py_Void();
8081 if (SWIG_IsTmpObj(res2)) {
8082 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8083 } else {
8084 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8086 }
8087 if (SWIG_IsTmpObj(res3)) {
8088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8089 } else {
8090 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8092 }
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8100 PyObject *resultobj = 0;
8101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8102 int *arg2 = (int *) 0 ;
8103 int *arg3 = (int *) 0 ;
8104 void *argp1 = 0 ;
8105 int res1 = 0 ;
8106 int temp2 ;
8107 int res2 = SWIG_TMPOBJ ;
8108 int temp3 ;
8109 int res3 = SWIG_TMPOBJ ;
8110 PyObject *swig_obj[1] ;
8111
8112 arg2 = &temp2;
8113 arg3 = &temp3;
8114 if (!args) SWIG_fail;
8115 swig_obj[0] = args;
8116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8117 if (!SWIG_IsOK(res1)) {
8118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8119 }
8120 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8124 wxPyEndAllowThreads(__tstate);
8125 if (PyErr_Occurred()) SWIG_fail;
8126 }
8127 resultobj = SWIG_Py_Void();
8128 if (SWIG_IsTmpObj(res2)) {
8129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8130 } else {
8131 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8133 }
8134 if (SWIG_IsTmpObj(res3)) {
8135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8136 } else {
8137 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8139 }
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8149 double result;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8159 }
8160 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8161 {
8162 PyThreadState* __tstate = wxPyBeginAllowThreads();
8163 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8164 wxPyEndAllowThreads(__tstate);
8165 if (PyErr_Occurred()) SWIG_fail;
8166 }
8167 resultobj = SWIG_From_double(static_cast< double >(result));
8168 return resultobj;
8169 fail:
8170 return NULL;
8171 }
8172
8173
8174 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8175 PyObject *resultobj = 0;
8176 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8177 double result;
8178 void *argp1 = 0 ;
8179 int res1 = 0 ;
8180 PyObject *swig_obj[1] ;
8181
8182 if (!args) SWIG_fail;
8183 swig_obj[0] = args;
8184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8185 if (!SWIG_IsOK(res1)) {
8186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8187 }
8188 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8189 {
8190 PyThreadState* __tstate = wxPyBeginAllowThreads();
8191 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_From_double(static_cast< double >(result));
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj = 0;
8204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8205 double arg2 ;
8206 void *argp1 = 0 ;
8207 int res1 = 0 ;
8208 double val2 ;
8209 int ecode2 = 0 ;
8210 PyObject * obj0 = 0 ;
8211 PyObject * obj1 = 0 ;
8212 char * kwnames[] = {
8213 (char *) "self",(char *) "length", NULL
8214 };
8215
8216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 ecode2 = SWIG_AsVal_double(obj1, &val2);
8223 if (!SWIG_IsOK(ecode2)) {
8224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8225 }
8226 arg2 = static_cast< double >(val2);
8227 {
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 (arg1)->SetVectorLength(arg2);
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 resultobj = SWIG_Py_Void();
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8241 PyObject *resultobj = 0;
8242 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8243 double arg2 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 double val2 ;
8247 int ecode2 = 0 ;
8248 PyObject * obj0 = 0 ;
8249 PyObject * obj1 = 0 ;
8250 char * kwnames[] = {
8251 (char *) "self",(char *) "degrees", NULL
8252 };
8253
8254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8256 if (!SWIG_IsOK(res1)) {
8257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8258 }
8259 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8260 ecode2 = SWIG_AsVal_double(obj1, &val2);
8261 if (!SWIG_IsOK(ecode2)) {
8262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8263 }
8264 arg2 = static_cast< double >(val2);
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 (arg1)->SetVectorAngle(arg2);
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_Py_Void();
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj = 0;
8280 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8281 wxPoint2D *arg2 = 0 ;
8282 double result;
8283 void *argp1 = 0 ;
8284 int res1 = 0 ;
8285 wxPoint2D temp2 ;
8286 PyObject * obj0 = 0 ;
8287 PyObject * obj1 = 0 ;
8288 char * kwnames[] = {
8289 (char *) "self",(char *) "pt", NULL
8290 };
8291
8292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8294 if (!SWIG_IsOK(res1)) {
8295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8296 }
8297 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8298 {
8299 arg2 = &temp2;
8300 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8301 }
8302 {
8303 PyThreadState* __tstate = wxPyBeginAllowThreads();
8304 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8305 wxPyEndAllowThreads(__tstate);
8306 if (PyErr_Occurred()) SWIG_fail;
8307 }
8308 resultobj = SWIG_From_double(static_cast< double >(result));
8309 return resultobj;
8310 fail:
8311 return NULL;
8312 }
8313
8314
8315 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8316 PyObject *resultobj = 0;
8317 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8318 wxPoint2D *arg2 = 0 ;
8319 double result;
8320 void *argp1 = 0 ;
8321 int res1 = 0 ;
8322 wxPoint2D temp2 ;
8323 PyObject * obj0 = 0 ;
8324 PyObject * obj1 = 0 ;
8325 char * kwnames[] = {
8326 (char *) "self",(char *) "pt", NULL
8327 };
8328
8329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8331 if (!SWIG_IsOK(res1)) {
8332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8333 }
8334 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8335 {
8336 arg2 = &temp2;
8337 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8342 wxPyEndAllowThreads(__tstate);
8343 if (PyErr_Occurred()) SWIG_fail;
8344 }
8345 resultobj = SWIG_From_double(static_cast< double >(result));
8346 return resultobj;
8347 fail:
8348 return NULL;
8349 }
8350
8351
8352 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8353 PyObject *resultobj = 0;
8354 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8355 wxPoint2D *arg2 = 0 ;
8356 double result;
8357 void *argp1 = 0 ;
8358 int res1 = 0 ;
8359 wxPoint2D temp2 ;
8360 PyObject * obj0 = 0 ;
8361 PyObject * obj1 = 0 ;
8362 char * kwnames[] = {
8363 (char *) "self",(char *) "vec", NULL
8364 };
8365
8366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8368 if (!SWIG_IsOK(res1)) {
8369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8370 }
8371 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8372 {
8373 arg2 = &temp2;
8374 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8375 }
8376 {
8377 PyThreadState* __tstate = wxPyBeginAllowThreads();
8378 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8379 wxPyEndAllowThreads(__tstate);
8380 if (PyErr_Occurred()) SWIG_fail;
8381 }
8382 resultobj = SWIG_From_double(static_cast< double >(result));
8383 return resultobj;
8384 fail:
8385 return NULL;
8386 }
8387
8388
8389 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8390 PyObject *resultobj = 0;
8391 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8392 wxPoint2D *arg2 = 0 ;
8393 double result;
8394 void *argp1 = 0 ;
8395 int res1 = 0 ;
8396 wxPoint2D temp2 ;
8397 PyObject * obj0 = 0 ;
8398 PyObject * obj1 = 0 ;
8399 char * kwnames[] = {
8400 (char *) "self",(char *) "vec", NULL
8401 };
8402
8403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8405 if (!SWIG_IsOK(res1)) {
8406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8407 }
8408 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8409 {
8410 arg2 = &temp2;
8411 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8412 }
8413 {
8414 PyThreadState* __tstate = wxPyBeginAllowThreads();
8415 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 resultobj = SWIG_From_double(static_cast< double >(result));
8420 return resultobj;
8421 fail:
8422 return NULL;
8423 }
8424
8425
8426 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8427 PyObject *resultobj = 0;
8428 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8429 wxPoint2D result;
8430 void *argp1 = 0 ;
8431 int res1 = 0 ;
8432 PyObject *swig_obj[1] ;
8433
8434 if (!args) SWIG_fail;
8435 swig_obj[0] = args;
8436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8437 if (!SWIG_IsOK(res1)) {
8438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8439 }
8440 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8441 {
8442 PyThreadState* __tstate = wxPyBeginAllowThreads();
8443 result = (arg1)->operator -();
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj = 0;
8456 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8457 wxPoint2D *arg2 = 0 ;
8458 wxPoint2D *result = 0 ;
8459 void *argp1 = 0 ;
8460 int res1 = 0 ;
8461 wxPoint2D temp2 ;
8462 PyObject * obj0 = 0 ;
8463 PyObject * obj1 = 0 ;
8464 char * kwnames[] = {
8465 (char *) "self",(char *) "pt", NULL
8466 };
8467
8468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8470 if (!SWIG_IsOK(res1)) {
8471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8472 }
8473 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8474 {
8475 arg2 = &temp2;
8476 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8477 }
8478 {
8479 PyThreadState* __tstate = wxPyBeginAllowThreads();
8480 {
8481 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8482 result = (wxPoint2D *) &_result_ref;
8483 }
8484 wxPyEndAllowThreads(__tstate);
8485 if (PyErr_Occurred()) SWIG_fail;
8486 }
8487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8488 return resultobj;
8489 fail:
8490 return NULL;
8491 }
8492
8493
8494 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj = 0;
8496 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8497 wxPoint2D *arg2 = 0 ;
8498 wxPoint2D *result = 0 ;
8499 void *argp1 = 0 ;
8500 int res1 = 0 ;
8501 wxPoint2D temp2 ;
8502 PyObject * obj0 = 0 ;
8503 PyObject * obj1 = 0 ;
8504 char * kwnames[] = {
8505 (char *) "self",(char *) "pt", NULL
8506 };
8507
8508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8510 if (!SWIG_IsOK(res1)) {
8511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8512 }
8513 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8514 {
8515 arg2 = &temp2;
8516 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8517 }
8518 {
8519 PyThreadState* __tstate = wxPyBeginAllowThreads();
8520 {
8521 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8522 result = (wxPoint2D *) &_result_ref;
8523 }
8524 wxPyEndAllowThreads(__tstate);
8525 if (PyErr_Occurred()) SWIG_fail;
8526 }
8527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8528 return resultobj;
8529 fail:
8530 return NULL;
8531 }
8532
8533
8534 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8535 PyObject *resultobj = 0;
8536 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8537 wxPoint2D *arg2 = 0 ;
8538 wxPoint2D *result = 0 ;
8539 void *argp1 = 0 ;
8540 int res1 = 0 ;
8541 wxPoint2D temp2 ;
8542 PyObject * obj0 = 0 ;
8543 PyObject * obj1 = 0 ;
8544 char * kwnames[] = {
8545 (char *) "self",(char *) "pt", NULL
8546 };
8547
8548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8550 if (!SWIG_IsOK(res1)) {
8551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8552 }
8553 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8554 {
8555 arg2 = &temp2;
8556 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8557 }
8558 {
8559 PyThreadState* __tstate = wxPyBeginAllowThreads();
8560 {
8561 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8562 result = (wxPoint2D *) &_result_ref;
8563 }
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 wxPoint2D *arg2 = 0 ;
8578 wxPoint2D *result = 0 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 wxPoint2D temp2 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "pt", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 {
8595 arg2 = &temp2;
8596 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8597 }
8598 {
8599 PyThreadState* __tstate = wxPyBeginAllowThreads();
8600 {
8601 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8602 result = (wxPoint2D *) &_result_ref;
8603 }
8604 wxPyEndAllowThreads(__tstate);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 PyObject *arg2 = (PyObject *) 0 ;
8618 bool result;
8619 void *argp1 = 0 ;
8620 int res1 = 0 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "other", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 arg2 = obj1;
8634 {
8635 result = (bool)wxPoint2D___eq__(arg1,arg2);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 {
8639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8640 }
8641 return resultobj;
8642 fail:
8643 return NULL;
8644 }
8645
8646
8647 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8648 PyObject *resultobj = 0;
8649 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8650 PyObject *arg2 = (PyObject *) 0 ;
8651 bool result;
8652 void *argp1 = 0 ;
8653 int res1 = 0 ;
8654 PyObject * obj0 = 0 ;
8655 PyObject * obj1 = 0 ;
8656 char * kwnames[] = {
8657 (char *) "self",(char *) "other", NULL
8658 };
8659
8660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8662 if (!SWIG_IsOK(res1)) {
8663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8664 }
8665 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8666 arg2 = obj1;
8667 {
8668 result = (bool)wxPoint2D___ne__(arg1,arg2);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 {
8672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8673 }
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8681 PyObject *resultobj = 0;
8682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8683 double arg2 ;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 double val2 ;
8687 int ecode2 = 0 ;
8688 PyObject *swig_obj[2] ;
8689
8690 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8692 if (!SWIG_IsOK(res1)) {
8693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8694 }
8695 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8696 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8697 if (!SWIG_IsOK(ecode2)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8699 }
8700 arg2 = static_cast< double >(val2);
8701 if (arg1) (arg1)->m_x = arg2;
8702
8703 resultobj = SWIG_Py_Void();
8704 return resultobj;
8705 fail:
8706 return NULL;
8707 }
8708
8709
8710 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8711 PyObject *resultobj = 0;
8712 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8713 double result;
8714 void *argp1 = 0 ;
8715 int res1 = 0 ;
8716 PyObject *swig_obj[1] ;
8717
8718 if (!args) SWIG_fail;
8719 swig_obj[0] = args;
8720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8721 if (!SWIG_IsOK(res1)) {
8722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8723 }
8724 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8725 result = (double) ((arg1)->m_x);
8726 resultobj = SWIG_From_double(static_cast< double >(result));
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8734 PyObject *resultobj = 0;
8735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8736 double arg2 ;
8737 void *argp1 = 0 ;
8738 int res1 = 0 ;
8739 double val2 ;
8740 int ecode2 = 0 ;
8741 PyObject *swig_obj[2] ;
8742
8743 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8745 if (!SWIG_IsOK(res1)) {
8746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8747 }
8748 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8749 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8750 if (!SWIG_IsOK(ecode2)) {
8751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8752 }
8753 arg2 = static_cast< double >(val2);
8754 if (arg1) (arg1)->m_y = arg2;
8755
8756 resultobj = SWIG_Py_Void();
8757 return resultobj;
8758 fail:
8759 return NULL;
8760 }
8761
8762
8763 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8764 PyObject *resultobj = 0;
8765 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8766 double result;
8767 void *argp1 = 0 ;
8768 int res1 = 0 ;
8769 PyObject *swig_obj[1] ;
8770
8771 if (!args) SWIG_fail;
8772 swig_obj[0] = args;
8773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8774 if (!SWIG_IsOK(res1)) {
8775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8776 }
8777 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8778 result = (double) ((arg1)->m_y);
8779 resultobj = SWIG_From_double(static_cast< double >(result));
8780 return resultobj;
8781 fail:
8782 return NULL;
8783 }
8784
8785
8786 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8787 PyObject *resultobj = 0;
8788 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8789 double arg2 = (double) 0 ;
8790 double arg3 = (double) 0 ;
8791 void *argp1 = 0 ;
8792 int res1 = 0 ;
8793 double val2 ;
8794 int ecode2 = 0 ;
8795 double val3 ;
8796 int ecode3 = 0 ;
8797 PyObject * obj0 = 0 ;
8798 PyObject * obj1 = 0 ;
8799 PyObject * obj2 = 0 ;
8800 char * kwnames[] = {
8801 (char *) "self",(char *) "x",(char *) "y", NULL
8802 };
8803
8804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8806 if (!SWIG_IsOK(res1)) {
8807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8808 }
8809 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8810 if (obj1) {
8811 ecode2 = SWIG_AsVal_double(obj1, &val2);
8812 if (!SWIG_IsOK(ecode2)) {
8813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8814 }
8815 arg2 = static_cast< double >(val2);
8816 }
8817 if (obj2) {
8818 ecode3 = SWIG_AsVal_double(obj2, &val3);
8819 if (!SWIG_IsOK(ecode3)) {
8820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8821 }
8822 arg3 = static_cast< double >(val3);
8823 }
8824 {
8825 PyThreadState* __tstate = wxPyBeginAllowThreads();
8826 wxPoint2D_Set(arg1,arg2,arg3);
8827 wxPyEndAllowThreads(__tstate);
8828 if (PyErr_Occurred()) SWIG_fail;
8829 }
8830 resultobj = SWIG_Py_Void();
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8840 PyObject *result = 0 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 PyObject *swig_obj[1] ;
8844
8845 if (!args) SWIG_fail;
8846 swig_obj[0] = args;
8847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8848 if (!SWIG_IsOK(res1)) {
8849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8850 }
8851 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 result = (PyObject *)wxPoint2D_Get(arg1);
8855 wxPyEndAllowThreads(__tstate);
8856 if (PyErr_Occurred()) SWIG_fail;
8857 }
8858 resultobj = result;
8859 return resultobj;
8860 fail:
8861 return NULL;
8862 }
8863
8864
8865 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8866 PyObject *obj;
8867 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8868 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8869 return SWIG_Py_Void();
8870 }
8871
8872 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8873 return SWIG_Python_InitShadowInstance(args);
8874 }
8875
8876 SWIGINTERN int DefaultPosition_set(PyObject *) {
8877 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8878 return 1;
8879 }
8880
8881
8882 SWIGINTERN PyObject *DefaultPosition_get(void) {
8883 PyObject *pyobj = 0;
8884
8885 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8886 return pyobj;
8887 }
8888
8889
8890 SWIGINTERN int DefaultSize_set(PyObject *) {
8891 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8892 return 1;
8893 }
8894
8895
8896 SWIGINTERN PyObject *DefaultSize_get(void) {
8897 PyObject *pyobj = 0;
8898
8899 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8900 return pyobj;
8901 }
8902
8903
8904 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj = 0;
8906 PyObject *arg1 = (PyObject *) 0 ;
8907 wxPyInputStream *result = 0 ;
8908 PyObject * obj0 = 0 ;
8909 char * kwnames[] = {
8910 (char *) "p", NULL
8911 };
8912
8913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8914 arg1 = obj0;
8915 {
8916 PyThreadState* __tstate = wxPyBeginAllowThreads();
8917 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8918 wxPyEndAllowThreads(__tstate);
8919 if (PyErr_Occurred()) SWIG_fail;
8920 }
8921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8922 return resultobj;
8923 fail:
8924 return NULL;
8925 }
8926
8927
8928 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8929 PyObject *resultobj = 0;
8930 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8931 void *argp1 = 0 ;
8932 int res1 = 0 ;
8933 PyObject *swig_obj[1] ;
8934
8935 if (!args) SWIG_fail;
8936 swig_obj[0] = args;
8937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8938 if (!SWIG_IsOK(res1)) {
8939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8940 }
8941 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8942 {
8943 PyThreadState* __tstate = wxPyBeginAllowThreads();
8944 delete arg1;
8945
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8959 void *argp1 = 0 ;
8960 int res1 = 0 ;
8961 PyObject *swig_obj[1] ;
8962
8963 if (!args) SWIG_fail;
8964 swig_obj[0] = args;
8965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8966 if (!SWIG_IsOK(res1)) {
8967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8968 }
8969 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 (arg1)->close();
8973 wxPyEndAllowThreads(__tstate);
8974 if (PyErr_Occurred()) SWIG_fail;
8975 }
8976 resultobj = SWIG_Py_Void();
8977 return resultobj;
8978 fail:
8979 return NULL;
8980 }
8981
8982
8983 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8984 PyObject *resultobj = 0;
8985 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8986 void *argp1 = 0 ;
8987 int res1 = 0 ;
8988 PyObject *swig_obj[1] ;
8989
8990 if (!args) SWIG_fail;
8991 swig_obj[0] = args;
8992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8993 if (!SWIG_IsOK(res1)) {
8994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8995 }
8996 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 (arg1)->flush();
9000 wxPyEndAllowThreads(__tstate);
9001 if (PyErr_Occurred()) SWIG_fail;
9002 }
9003 resultobj = SWIG_Py_Void();
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011 PyObject *resultobj = 0;
9012 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9013 bool result;
9014 void *argp1 = 0 ;
9015 int res1 = 0 ;
9016 PyObject *swig_obj[1] ;
9017
9018 if (!args) SWIG_fail;
9019 swig_obj[0] = args;
9020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9021 if (!SWIG_IsOK(res1)) {
9022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9023 }
9024 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9025 {
9026 PyThreadState* __tstate = wxPyBeginAllowThreads();
9027 result = (bool)(arg1)->eof();
9028 wxPyEndAllowThreads(__tstate);
9029 if (PyErr_Occurred()) SWIG_fail;
9030 }
9031 {
9032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9033 }
9034 return resultobj;
9035 fail:
9036 return NULL;
9037 }
9038
9039
9040 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9041 PyObject *resultobj = 0;
9042 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9043 int arg2 = (int) -1 ;
9044 PyObject *result = 0 ;
9045 void *argp1 = 0 ;
9046 int res1 = 0 ;
9047 int val2 ;
9048 int ecode2 = 0 ;
9049 PyObject * obj0 = 0 ;
9050 PyObject * obj1 = 0 ;
9051 char * kwnames[] = {
9052 (char *) "self",(char *) "size", NULL
9053 };
9054
9055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9059 }
9060 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9061 if (obj1) {
9062 ecode2 = SWIG_AsVal_int(obj1, &val2);
9063 if (!SWIG_IsOK(ecode2)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9065 }
9066 arg2 = static_cast< int >(val2);
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = (PyObject *)(arg1)->read(arg2);
9071 wxPyEndAllowThreads(__tstate);
9072 if (PyErr_Occurred()) SWIG_fail;
9073 }
9074 resultobj = result;
9075 return resultobj;
9076 fail:
9077 return NULL;
9078 }
9079
9080
9081 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9082 PyObject *resultobj = 0;
9083 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9084 int arg2 = (int) -1 ;
9085 PyObject *result = 0 ;
9086 void *argp1 = 0 ;
9087 int res1 = 0 ;
9088 int val2 ;
9089 int ecode2 = 0 ;
9090 PyObject * obj0 = 0 ;
9091 PyObject * obj1 = 0 ;
9092 char * kwnames[] = {
9093 (char *) "self",(char *) "size", NULL
9094 };
9095
9096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9098 if (!SWIG_IsOK(res1)) {
9099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9100 }
9101 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9102 if (obj1) {
9103 ecode2 = SWIG_AsVal_int(obj1, &val2);
9104 if (!SWIG_IsOK(ecode2)) {
9105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9106 }
9107 arg2 = static_cast< int >(val2);
9108 }
9109 {
9110 PyThreadState* __tstate = wxPyBeginAllowThreads();
9111 result = (PyObject *)(arg1)->readline(arg2);
9112 wxPyEndAllowThreads(__tstate);
9113 if (PyErr_Occurred()) SWIG_fail;
9114 }
9115 resultobj = result;
9116 return resultobj;
9117 fail:
9118 return NULL;
9119 }
9120
9121
9122 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9123 PyObject *resultobj = 0;
9124 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9125 int arg2 = (int) -1 ;
9126 PyObject *result = 0 ;
9127 void *argp1 = 0 ;
9128 int res1 = 0 ;
9129 int val2 ;
9130 int ecode2 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 char * kwnames[] = {
9134 (char *) "self",(char *) "sizehint", NULL
9135 };
9136
9137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9139 if (!SWIG_IsOK(res1)) {
9140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9141 }
9142 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9143 if (obj1) {
9144 ecode2 = SWIG_AsVal_int(obj1, &val2);
9145 if (!SWIG_IsOK(ecode2)) {
9146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9147 }
9148 arg2 = static_cast< int >(val2);
9149 }
9150 {
9151 PyThreadState* __tstate = wxPyBeginAllowThreads();
9152 result = (PyObject *)(arg1)->readlines(arg2);
9153 wxPyEndAllowThreads(__tstate);
9154 if (PyErr_Occurred()) SWIG_fail;
9155 }
9156 resultobj = result;
9157 return resultobj;
9158 fail:
9159 return NULL;
9160 }
9161
9162
9163 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj = 0;
9165 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9166 int arg2 ;
9167 int arg3 = (int) 0 ;
9168 void *argp1 = 0 ;
9169 int res1 = 0 ;
9170 int val2 ;
9171 int ecode2 = 0 ;
9172 int val3 ;
9173 int ecode3 = 0 ;
9174 PyObject * obj0 = 0 ;
9175 PyObject * obj1 = 0 ;
9176 PyObject * obj2 = 0 ;
9177 char * kwnames[] = {
9178 (char *) "self",(char *) "offset",(char *) "whence", NULL
9179 };
9180
9181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9183 if (!SWIG_IsOK(res1)) {
9184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9185 }
9186 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9187 ecode2 = SWIG_AsVal_int(obj1, &val2);
9188 if (!SWIG_IsOK(ecode2)) {
9189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9190 }
9191 arg2 = static_cast< int >(val2);
9192 if (obj2) {
9193 ecode3 = SWIG_AsVal_int(obj2, &val3);
9194 if (!SWIG_IsOK(ecode3)) {
9195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9196 }
9197 arg3 = static_cast< int >(val3);
9198 }
9199 {
9200 PyThreadState* __tstate = wxPyBeginAllowThreads();
9201 (arg1)->seek(arg2,arg3);
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 resultobj = SWIG_Py_Void();
9206 return resultobj;
9207 fail:
9208 return NULL;
9209 }
9210
9211
9212 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9213 PyObject *resultobj = 0;
9214 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9215 int result;
9216 void *argp1 = 0 ;
9217 int res1 = 0 ;
9218 PyObject *swig_obj[1] ;
9219
9220 if (!args) SWIG_fail;
9221 swig_obj[0] = args;
9222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9223 if (!SWIG_IsOK(res1)) {
9224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9225 }
9226 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (int)(arg1)->tell();
9230 wxPyEndAllowThreads(__tstate);
9231 if (PyErr_Occurred()) SWIG_fail;
9232 }
9233 resultobj = SWIG_From_int(static_cast< int >(result));
9234 return resultobj;
9235 fail:
9236 return NULL;
9237 }
9238
9239
9240 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9241 PyObject *resultobj = 0;
9242 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9243 char result;
9244 void *argp1 = 0 ;
9245 int res1 = 0 ;
9246 PyObject *swig_obj[1] ;
9247
9248 if (!args) SWIG_fail;
9249 swig_obj[0] = args;
9250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9251 if (!SWIG_IsOK(res1)) {
9252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9253 }
9254 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = (char)(arg1)->Peek();
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 resultobj = SWIG_From_char(static_cast< char >(result));
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9269 PyObject *resultobj = 0;
9270 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9271 char result;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 PyObject *swig_obj[1] ;
9275
9276 if (!args) SWIG_fail;
9277 swig_obj[0] = args;
9278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9279 if (!SWIG_IsOK(res1)) {
9280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9281 }
9282 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9283 {
9284 PyThreadState* __tstate = wxPyBeginAllowThreads();
9285 result = (char)(arg1)->GetC();
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_From_char(static_cast< char >(result));
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9297 PyObject *resultobj = 0;
9298 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9299 size_t result;
9300 void *argp1 = 0 ;
9301 int res1 = 0 ;
9302 PyObject *swig_obj[1] ;
9303
9304 if (!args) SWIG_fail;
9305 swig_obj[0] = args;
9306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9309 }
9310 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (size_t)(arg1)->LastRead();
9314 wxPyEndAllowThreads(__tstate);
9315 if (PyErr_Occurred()) SWIG_fail;
9316 }
9317 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9318 return resultobj;
9319 fail:
9320 return NULL;
9321 }
9322
9323
9324 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9325 PyObject *resultobj = 0;
9326 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9327 bool result;
9328 void *argp1 = 0 ;
9329 int res1 = 0 ;
9330 PyObject *swig_obj[1] ;
9331
9332 if (!args) SWIG_fail;
9333 swig_obj[0] = args;
9334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9335 if (!SWIG_IsOK(res1)) {
9336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9337 }
9338 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9339 {
9340 PyThreadState* __tstate = wxPyBeginAllowThreads();
9341 result = (bool)(arg1)->CanRead();
9342 wxPyEndAllowThreads(__tstate);
9343 if (PyErr_Occurred()) SWIG_fail;
9344 }
9345 {
9346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9347 }
9348 return resultobj;
9349 fail:
9350 return NULL;
9351 }
9352
9353
9354 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9355 PyObject *resultobj = 0;
9356 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9357 bool result;
9358 void *argp1 = 0 ;
9359 int res1 = 0 ;
9360 PyObject *swig_obj[1] ;
9361
9362 if (!args) SWIG_fail;
9363 swig_obj[0] = args;
9364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 result = (bool)(arg1)->Eof();
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 {
9376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9377 }
9378 return resultobj;
9379 fail:
9380 return NULL;
9381 }
9382
9383
9384 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9385 PyObject *resultobj = 0;
9386 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9387 char arg2 ;
9388 bool result;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 char val2 ;
9392 int ecode2 = 0 ;
9393 PyObject * obj0 = 0 ;
9394 PyObject * obj1 = 0 ;
9395 char * kwnames[] = {
9396 (char *) "self",(char *) "c", NULL
9397 };
9398
9399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9401 if (!SWIG_IsOK(res1)) {
9402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9403 }
9404 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9405 ecode2 = SWIG_AsVal_char(obj1, &val2);
9406 if (!SWIG_IsOK(ecode2)) {
9407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9408 }
9409 arg2 = static_cast< char >(val2);
9410 {
9411 PyThreadState* __tstate = wxPyBeginAllowThreads();
9412 result = (bool)(arg1)->Ungetch(arg2);
9413 wxPyEndAllowThreads(__tstate);
9414 if (PyErr_Occurred()) SWIG_fail;
9415 }
9416 {
9417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9418 }
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj = 0;
9427 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9428 long arg2 ;
9429 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9430 long result;
9431 void *argp1 = 0 ;
9432 int res1 = 0 ;
9433 long val2 ;
9434 int ecode2 = 0 ;
9435 int val3 ;
9436 int ecode3 = 0 ;
9437 PyObject * obj0 = 0 ;
9438 PyObject * obj1 = 0 ;
9439 PyObject * obj2 = 0 ;
9440 char * kwnames[] = {
9441 (char *) "self",(char *) "pos",(char *) "mode", NULL
9442 };
9443
9444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9446 if (!SWIG_IsOK(res1)) {
9447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9448 }
9449 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9450 ecode2 = SWIG_AsVal_long(obj1, &val2);
9451 if (!SWIG_IsOK(ecode2)) {
9452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9453 }
9454 arg2 = static_cast< long >(val2);
9455 if (obj2) {
9456 ecode3 = SWIG_AsVal_int(obj2, &val3);
9457 if (!SWIG_IsOK(ecode3)) {
9458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9459 }
9460 arg3 = static_cast< wxSeekMode >(val3);
9461 }
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (long)(arg1)->SeekI(arg2,arg3);
9465 wxPyEndAllowThreads(__tstate);
9466 if (PyErr_Occurred()) SWIG_fail;
9467 }
9468 resultobj = SWIG_From_long(static_cast< long >(result));
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9476 PyObject *resultobj = 0;
9477 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9478 long result;
9479 void *argp1 = 0 ;
9480 int res1 = 0 ;
9481 PyObject *swig_obj[1] ;
9482
9483 if (!args) SWIG_fail;
9484 swig_obj[0] = args;
9485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9486 if (!SWIG_IsOK(res1)) {
9487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9488 }
9489 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (long)(arg1)->TellI();
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 resultobj = SWIG_From_long(static_cast< long >(result));
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9504 PyObject *obj;
9505 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9506 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9507 return SWIG_Py_Void();
9508 }
9509
9510 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9511 return SWIG_Python_InitShadowInstance(args);
9512 }
9513
9514 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9515 PyObject *resultobj = 0;
9516 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9517 PyObject *arg2 = (PyObject *) 0 ;
9518 void *argp1 = 0 ;
9519 int res1 = 0 ;
9520 PyObject * obj0 = 0 ;
9521 PyObject * obj1 = 0 ;
9522 char * kwnames[] = {
9523 (char *) "self",(char *) "obj", NULL
9524 };
9525
9526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9528 if (!SWIG_IsOK(res1)) {
9529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9530 }
9531 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9532 arg2 = obj1;
9533 {
9534 PyThreadState* __tstate = wxPyBeginAllowThreads();
9535 wxOutputStream_write(arg1,arg2);
9536 wxPyEndAllowThreads(__tstate);
9537 if (PyErr_Occurred()) SWIG_fail;
9538 }
9539 resultobj = SWIG_Py_Void();
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9547 PyObject *resultobj = 0;
9548 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9549 size_t result;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 PyObject *swig_obj[1] ;
9553
9554 if (!args) SWIG_fail;
9555 swig_obj[0] = args;
9556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9557 if (!SWIG_IsOK(res1)) {
9558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9559 }
9560 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9564 wxPyEndAllowThreads(__tstate);
9565 if (PyErr_Occurred()) SWIG_fail;
9566 }
9567 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9568 return resultobj;
9569 fail:
9570 return NULL;
9571 }
9572
9573
9574 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9575 PyObject *obj;
9576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9577 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9578 return SWIG_Py_Void();
9579 }
9580
9581 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9582 PyObject *resultobj = 0;
9583 wxInputStream *arg1 = (wxInputStream *) 0 ;
9584 wxString *arg2 = 0 ;
9585 wxString *arg3 = 0 ;
9586 wxString *arg4 = 0 ;
9587 wxDateTime arg5 ;
9588 wxFSFile *result = 0 ;
9589 wxPyInputStream *temp1 ;
9590 bool temp2 = false ;
9591 bool temp3 = false ;
9592 bool temp4 = false ;
9593 void *argp5 ;
9594 int res5 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 PyObject * obj2 = 0 ;
9598 PyObject * obj3 = 0 ;
9599 PyObject * obj4 = 0 ;
9600 char * kwnames[] = {
9601 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9602 };
9603
9604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9605 {
9606 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9607 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9608 } else {
9609 PyErr_Clear(); // clear the failure of the wxPyConvert above
9610 arg1 = wxPyCBInputStream_create(obj0, true);
9611 if (arg1 == NULL) {
9612 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9613 SWIG_fail;
9614 }
9615 }
9616 }
9617 {
9618 arg2 = wxString_in_helper(obj1);
9619 if (arg2 == NULL) SWIG_fail;
9620 temp2 = true;
9621 }
9622 {
9623 arg3 = wxString_in_helper(obj2);
9624 if (arg3 == NULL) SWIG_fail;
9625 temp3 = true;
9626 }
9627 {
9628 arg4 = wxString_in_helper(obj3);
9629 if (arg4 == NULL) SWIG_fail;
9630 temp4 = true;
9631 }
9632 {
9633 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9634 if (!SWIG_IsOK(res5)) {
9635 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9636 }
9637 if (!argp5) {
9638 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9639 } else {
9640 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9641 arg5 = *temp;
9642 if (SWIG_IsNewObj(res5)) delete temp;
9643 }
9644 }
9645 {
9646 PyThreadState* __tstate = wxPyBeginAllowThreads();
9647 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9648 wxPyEndAllowThreads(__tstate);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 {
9652 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9653 }
9654 {
9655 if (temp2)
9656 delete arg2;
9657 }
9658 {
9659 if (temp3)
9660 delete arg3;
9661 }
9662 {
9663 if (temp4)
9664 delete arg4;
9665 }
9666 return resultobj;
9667 fail:
9668 {
9669 if (temp2)
9670 delete arg2;
9671 }
9672 {
9673 if (temp3)
9674 delete arg3;
9675 }
9676 {
9677 if (temp4)
9678 delete arg4;
9679 }
9680 return NULL;
9681 }
9682
9683
9684 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9685 PyObject *resultobj = 0;
9686 wxFSFile *arg1 = (wxFSFile *) 0 ;
9687 void *argp1 = 0 ;
9688 int res1 = 0 ;
9689 PyObject *swig_obj[1] ;
9690
9691 if (!args) SWIG_fail;
9692 swig_obj[0] = args;
9693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9694 if (!SWIG_IsOK(res1)) {
9695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9696 }
9697 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 delete arg1;
9701
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 resultobj = SWIG_Py_Void();
9706 return resultobj;
9707 fail:
9708 return NULL;
9709 }
9710
9711
9712 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9713 PyObject *resultobj = 0;
9714 wxFSFile *arg1 = (wxFSFile *) 0 ;
9715 wxInputStream *result = 0 ;
9716 void *argp1 = 0 ;
9717 int res1 = 0 ;
9718 PyObject *swig_obj[1] ;
9719
9720 if (!args) SWIG_fail;
9721 swig_obj[0] = args;
9722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9723 if (!SWIG_IsOK(res1)) {
9724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9725 }
9726 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9727 {
9728 PyThreadState* __tstate = wxPyBeginAllowThreads();
9729 result = (wxInputStream *)(arg1)->GetStream();
9730 wxPyEndAllowThreads(__tstate);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 {
9734 wxPyInputStream * _ptr = NULL;
9735
9736 if (result) {
9737 _ptr = new wxPyInputStream(result);
9738 }
9739 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9740 }
9741 return resultobj;
9742 fail:
9743 return NULL;
9744 }
9745
9746
9747 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9748 PyObject *resultobj = 0;
9749 wxFSFile *arg1 = (wxFSFile *) 0 ;
9750 wxString *result = 0 ;
9751 void *argp1 = 0 ;
9752 int res1 = 0 ;
9753 PyObject *swig_obj[1] ;
9754
9755 if (!args) SWIG_fail;
9756 swig_obj[0] = args;
9757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9758 if (!SWIG_IsOK(res1)) {
9759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9760 }
9761 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9762 {
9763 PyThreadState* __tstate = wxPyBeginAllowThreads();
9764 {
9765 wxString const &_result_ref = (arg1)->GetMimeType();
9766 result = (wxString *) &_result_ref;
9767 }
9768 wxPyEndAllowThreads(__tstate);
9769 if (PyErr_Occurred()) SWIG_fail;
9770 }
9771 {
9772 #if wxUSE_UNICODE
9773 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9774 #else
9775 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9776 #endif
9777 }
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9785 PyObject *resultobj = 0;
9786 wxFSFile *arg1 = (wxFSFile *) 0 ;
9787 wxString *result = 0 ;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 PyObject *swig_obj[1] ;
9791
9792 if (!args) SWIG_fail;
9793 swig_obj[0] = args;
9794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9795 if (!SWIG_IsOK(res1)) {
9796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9797 }
9798 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 {
9802 wxString const &_result_ref = (arg1)->GetLocation();
9803 result = (wxString *) &_result_ref;
9804 }
9805 wxPyEndAllowThreads(__tstate);
9806 if (PyErr_Occurred()) SWIG_fail;
9807 }
9808 {
9809 #if wxUSE_UNICODE
9810 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9811 #else
9812 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9813 #endif
9814 }
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9822 PyObject *resultobj = 0;
9823 wxFSFile *arg1 = (wxFSFile *) 0 ;
9824 wxString *result = 0 ;
9825 void *argp1 = 0 ;
9826 int res1 = 0 ;
9827 PyObject *swig_obj[1] ;
9828
9829 if (!args) SWIG_fail;
9830 swig_obj[0] = args;
9831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9832 if (!SWIG_IsOK(res1)) {
9833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9834 }
9835 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 {
9839 wxString const &_result_ref = (arg1)->GetAnchor();
9840 result = (wxString *) &_result_ref;
9841 }
9842 wxPyEndAllowThreads(__tstate);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 {
9846 #if wxUSE_UNICODE
9847 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9848 #else
9849 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9850 #endif
9851 }
9852 return resultobj;
9853 fail:
9854 return NULL;
9855 }
9856
9857
9858 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9859 PyObject *resultobj = 0;
9860 wxFSFile *arg1 = (wxFSFile *) 0 ;
9861 wxDateTime result;
9862 void *argp1 = 0 ;
9863 int res1 = 0 ;
9864 PyObject *swig_obj[1] ;
9865
9866 if (!args) SWIG_fail;
9867 swig_obj[0] = args;
9868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9869 if (!SWIG_IsOK(res1)) {
9870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9871 }
9872 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9873 {
9874 PyThreadState* __tstate = wxPyBeginAllowThreads();
9875 result = (arg1)->GetModificationTime();
9876 wxPyEndAllowThreads(__tstate);
9877 if (PyErr_Occurred()) SWIG_fail;
9878 }
9879 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9880 return resultobj;
9881 fail:
9882 return NULL;
9883 }
9884
9885
9886 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9887 PyObject *obj;
9888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9889 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9890 return SWIG_Py_Void();
9891 }
9892
9893 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 return SWIG_Python_InitShadowInstance(args);
9895 }
9896
9897 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9898 PyObject *resultobj = 0;
9899 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9900 void *argp1 = 0 ;
9901 int res1 = 0 ;
9902 PyObject *swig_obj[1] ;
9903
9904 if (!args) SWIG_fail;
9905 swig_obj[0] = args;
9906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9907 if (!SWIG_IsOK(res1)) {
9908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9909 }
9910 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 delete arg1;
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_Py_Void();
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *obj;
9927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9928 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9929 return SWIG_Py_Void();
9930 }
9931
9932 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9933 PyObject *resultobj = 0;
9934 wxPyFileSystemHandler *result = 0 ;
9935
9936 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9937 {
9938 PyThreadState* __tstate = wxPyBeginAllowThreads();
9939 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9940 wxPyEndAllowThreads(__tstate);
9941 if (PyErr_Occurred()) SWIG_fail;
9942 }
9943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9951 PyObject *resultobj = 0;
9952 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9953 PyObject *arg2 = (PyObject *) 0 ;
9954 PyObject *arg3 = (PyObject *) 0 ;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 PyObject * obj0 = 0 ;
9958 PyObject * obj1 = 0 ;
9959 PyObject * obj2 = 0 ;
9960 char * kwnames[] = {
9961 (char *) "self",(char *) "self",(char *) "_class", NULL
9962 };
9963
9964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9968 }
9969 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9970 arg2 = obj1;
9971 arg3 = obj2;
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 (arg1)->_setCallbackInfo(arg2,arg3);
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj = 0;
9987 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9988 wxString *arg2 = 0 ;
9989 bool result;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 bool temp2 = false ;
9993 PyObject * obj0 = 0 ;
9994 PyObject * obj1 = 0 ;
9995 char * kwnames[] = {
9996 (char *) "self",(char *) "location", NULL
9997 };
9998
9999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10001 if (!SWIG_IsOK(res1)) {
10002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10003 }
10004 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10005 {
10006 arg2 = wxString_in_helper(obj1);
10007 if (arg2 == NULL) SWIG_fail;
10008 temp2 = true;
10009 }
10010 {
10011 PyThreadState* __tstate = wxPyBeginAllowThreads();
10012 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10013 wxPyEndAllowThreads(__tstate);
10014 if (PyErr_Occurred()) SWIG_fail;
10015 }
10016 {
10017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10018 }
10019 {
10020 if (temp2)
10021 delete arg2;
10022 }
10023 return resultobj;
10024 fail:
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return NULL;
10030 }
10031
10032
10033 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10034 PyObject *resultobj = 0;
10035 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10036 wxFileSystem *arg2 = 0 ;
10037 wxString *arg3 = 0 ;
10038 wxFSFile *result = 0 ;
10039 void *argp1 = 0 ;
10040 int res1 = 0 ;
10041 void *argp2 = 0 ;
10042 int res2 = 0 ;
10043 bool temp3 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 PyObject * obj2 = 0 ;
10047 char * kwnames[] = {
10048 (char *) "self",(char *) "fs",(char *) "location", NULL
10049 };
10050
10051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10055 }
10056 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10058 if (!SWIG_IsOK(res2)) {
10059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10060 }
10061 if (!argp2) {
10062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10063 }
10064 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10065 {
10066 arg3 = wxString_in_helper(obj2);
10067 if (arg3 == NULL) SWIG_fail;
10068 temp3 = true;
10069 }
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10073 wxPyEndAllowThreads(__tstate);
10074 if (PyErr_Occurred()) SWIG_fail;
10075 }
10076 {
10077 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10078 }
10079 {
10080 if (temp3)
10081 delete arg3;
10082 }
10083 return resultobj;
10084 fail:
10085 {
10086 if (temp3)
10087 delete arg3;
10088 }
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10094 PyObject *resultobj = 0;
10095 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10096 wxString *arg2 = 0 ;
10097 int arg3 = (int) 0 ;
10098 wxString result;
10099 void *argp1 = 0 ;
10100 int res1 = 0 ;
10101 bool temp2 = false ;
10102 int val3 ;
10103 int ecode3 = 0 ;
10104 PyObject * obj0 = 0 ;
10105 PyObject * obj1 = 0 ;
10106 PyObject * obj2 = 0 ;
10107 char * kwnames[] = {
10108 (char *) "self",(char *) "spec",(char *) "flags", NULL
10109 };
10110
10111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10113 if (!SWIG_IsOK(res1)) {
10114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10115 }
10116 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10117 {
10118 arg2 = wxString_in_helper(obj1);
10119 if (arg2 == NULL) SWIG_fail;
10120 temp2 = true;
10121 }
10122 if (obj2) {
10123 ecode3 = SWIG_AsVal_int(obj2, &val3);
10124 if (!SWIG_IsOK(ecode3)) {
10125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10126 }
10127 arg3 = static_cast< int >(val3);
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 #if wxUSE_UNICODE
10137 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10138 #else
10139 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10140 #endif
10141 }
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return resultobj;
10147 fail:
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return NULL;
10153 }
10154
10155
10156 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10157 PyObject *resultobj = 0;
10158 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10159 wxString result;
10160 void *argp1 = 0 ;
10161 int res1 = 0 ;
10162 PyObject *swig_obj[1] ;
10163
10164 if (!args) SWIG_fail;
10165 swig_obj[0] = args;
10166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10167 if (!SWIG_IsOK(res1)) {
10168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10169 }
10170 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 result = (arg1)->FindNext();
10174 wxPyEndAllowThreads(__tstate);
10175 if (PyErr_Occurred()) SWIG_fail;
10176 }
10177 {
10178 #if wxUSE_UNICODE
10179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10180 #else
10181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10182 #endif
10183 }
10184 return resultobj;
10185 fail:
10186 return NULL;
10187 }
10188
10189
10190 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10191 PyObject *resultobj = 0;
10192 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10193 wxString *arg2 = 0 ;
10194 wxString result;
10195 void *argp1 = 0 ;
10196 int res1 = 0 ;
10197 bool temp2 = false ;
10198 PyObject * obj0 = 0 ;
10199 PyObject * obj1 = 0 ;
10200 char * kwnames[] = {
10201 (char *) "self",(char *) "location", NULL
10202 };
10203
10204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10206 if (!SWIG_IsOK(res1)) {
10207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10208 }
10209 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10210 {
10211 arg2 = wxString_in_helper(obj1);
10212 if (arg2 == NULL) SWIG_fail;
10213 temp2 = true;
10214 }
10215 {
10216 PyThreadState* __tstate = wxPyBeginAllowThreads();
10217 result = (arg1)->GetProtocol((wxString const &)*arg2);
10218 wxPyEndAllowThreads(__tstate);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 {
10222 #if wxUSE_UNICODE
10223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10224 #else
10225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10226 #endif
10227 }
10228 {
10229 if (temp2)
10230 delete arg2;
10231 }
10232 return resultobj;
10233 fail:
10234 {
10235 if (temp2)
10236 delete arg2;
10237 }
10238 return NULL;
10239 }
10240
10241
10242 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10243 PyObject *resultobj = 0;
10244 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10245 wxString *arg2 = 0 ;
10246 wxString result;
10247 void *argp1 = 0 ;
10248 int res1 = 0 ;
10249 bool temp2 = false ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 char * kwnames[] = {
10253 (char *) "self",(char *) "location", NULL
10254 };
10255
10256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10258 if (!SWIG_IsOK(res1)) {
10259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10260 }
10261 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10262 {
10263 arg2 = wxString_in_helper(obj1);
10264 if (arg2 == NULL) SWIG_fail;
10265 temp2 = true;
10266 }
10267 {
10268 PyThreadState* __tstate = wxPyBeginAllowThreads();
10269 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 {
10274 #if wxUSE_UNICODE
10275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10276 #else
10277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10278 #endif
10279 }
10280 {
10281 if (temp2)
10282 delete arg2;
10283 }
10284 return resultobj;
10285 fail:
10286 {
10287 if (temp2)
10288 delete arg2;
10289 }
10290 return NULL;
10291 }
10292
10293
10294 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10295 PyObject *resultobj = 0;
10296 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10297 wxString *arg2 = 0 ;
10298 wxString result;
10299 void *argp1 = 0 ;
10300 int res1 = 0 ;
10301 bool temp2 = false ;
10302 PyObject * obj0 = 0 ;
10303 PyObject * obj1 = 0 ;
10304 char * kwnames[] = {
10305 (char *) "self",(char *) "location", NULL
10306 };
10307
10308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10310 if (!SWIG_IsOK(res1)) {
10311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10312 }
10313 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10314 {
10315 arg2 = wxString_in_helper(obj1);
10316 if (arg2 == NULL) SWIG_fail;
10317 temp2 = true;
10318 }
10319 {
10320 PyThreadState* __tstate = wxPyBeginAllowThreads();
10321 result = (arg1)->GetAnchor((wxString const &)*arg2);
10322 wxPyEndAllowThreads(__tstate);
10323 if (PyErr_Occurred()) SWIG_fail;
10324 }
10325 {
10326 #if wxUSE_UNICODE
10327 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10328 #else
10329 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10330 #endif
10331 }
10332 {
10333 if (temp2)
10334 delete arg2;
10335 }
10336 return resultobj;
10337 fail:
10338 {
10339 if (temp2)
10340 delete arg2;
10341 }
10342 return NULL;
10343 }
10344
10345
10346 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10347 PyObject *resultobj = 0;
10348 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10349 wxString *arg2 = 0 ;
10350 wxString result;
10351 void *argp1 = 0 ;
10352 int res1 = 0 ;
10353 bool temp2 = false ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 char * kwnames[] = {
10357 (char *) "self",(char *) "location", NULL
10358 };
10359
10360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10362 if (!SWIG_IsOK(res1)) {
10363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10364 }
10365 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10366 {
10367 arg2 = wxString_in_helper(obj1);
10368 if (arg2 == NULL) SWIG_fail;
10369 temp2 = true;
10370 }
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 {
10378 #if wxUSE_UNICODE
10379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10380 #else
10381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10382 #endif
10383 }
10384 {
10385 if (temp2)
10386 delete arg2;
10387 }
10388 return resultobj;
10389 fail:
10390 {
10391 if (temp2)
10392 delete arg2;
10393 }
10394 return NULL;
10395 }
10396
10397
10398 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10399 PyObject *resultobj = 0;
10400 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10401 wxString *arg2 = 0 ;
10402 wxString result;
10403 void *argp1 = 0 ;
10404 int res1 = 0 ;
10405 bool temp2 = false ;
10406 PyObject * obj0 = 0 ;
10407 PyObject * obj1 = 0 ;
10408 char * kwnames[] = {
10409 (char *) "self",(char *) "location", NULL
10410 };
10411
10412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10414 if (!SWIG_IsOK(res1)) {
10415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10416 }
10417 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10418 {
10419 arg2 = wxString_in_helper(obj1);
10420 if (arg2 == NULL) SWIG_fail;
10421 temp2 = true;
10422 }
10423 {
10424 PyThreadState* __tstate = wxPyBeginAllowThreads();
10425 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10426 wxPyEndAllowThreads(__tstate);
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 #if wxUSE_UNICODE
10431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10432 #else
10433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10434 #endif
10435 }
10436 {
10437 if (temp2)
10438 delete arg2;
10439 }
10440 return resultobj;
10441 fail:
10442 {
10443 if (temp2)
10444 delete arg2;
10445 }
10446 return NULL;
10447 }
10448
10449
10450 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10451 PyObject *obj;
10452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10453 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10454 return SWIG_Py_Void();
10455 }
10456
10457 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 return SWIG_Python_InitShadowInstance(args);
10459 }
10460
10461 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10462 PyObject *resultobj = 0;
10463 wxFileSystem *result = 0 ;
10464
10465 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10466 {
10467 PyThreadState* __tstate = wxPyBeginAllowThreads();
10468 result = (wxFileSystem *)new wxFileSystem();
10469 wxPyEndAllowThreads(__tstate);
10470 if (PyErr_Occurred()) SWIG_fail;
10471 }
10472 {
10473 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10474 }
10475 return resultobj;
10476 fail:
10477 return NULL;
10478 }
10479
10480
10481 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10482 PyObject *resultobj = 0;
10483 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10484 void *argp1 = 0 ;
10485 int res1 = 0 ;
10486 PyObject *swig_obj[1] ;
10487
10488 if (!args) SWIG_fail;
10489 swig_obj[0] = args;
10490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10491 if (!SWIG_IsOK(res1)) {
10492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10493 }
10494 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10495 {
10496 PyThreadState* __tstate = wxPyBeginAllowThreads();
10497 delete arg1;
10498
10499 wxPyEndAllowThreads(__tstate);
10500 if (PyErr_Occurred()) SWIG_fail;
10501 }
10502 resultobj = SWIG_Py_Void();
10503 return resultobj;
10504 fail:
10505 return NULL;
10506 }
10507
10508
10509 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10510 PyObject *resultobj = 0;
10511 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10512 wxString *arg2 = 0 ;
10513 bool arg3 = (bool) false ;
10514 void *argp1 = 0 ;
10515 int res1 = 0 ;
10516 bool temp2 = false ;
10517 bool val3 ;
10518 int ecode3 = 0 ;
10519 PyObject * obj0 = 0 ;
10520 PyObject * obj1 = 0 ;
10521 PyObject * obj2 = 0 ;
10522 char * kwnames[] = {
10523 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10524 };
10525
10526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10528 if (!SWIG_IsOK(res1)) {
10529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10530 }
10531 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10532 {
10533 arg2 = wxString_in_helper(obj1);
10534 if (arg2 == NULL) SWIG_fail;
10535 temp2 = true;
10536 }
10537 if (obj2) {
10538 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10539 if (!SWIG_IsOK(ecode3)) {
10540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10541 }
10542 arg3 = static_cast< bool >(val3);
10543 }
10544 {
10545 PyThreadState* __tstate = wxPyBeginAllowThreads();
10546 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10547 wxPyEndAllowThreads(__tstate);
10548 if (PyErr_Occurred()) SWIG_fail;
10549 }
10550 resultobj = SWIG_Py_Void();
10551 {
10552 if (temp2)
10553 delete arg2;
10554 }
10555 return resultobj;
10556 fail:
10557 {
10558 if (temp2)
10559 delete arg2;
10560 }
10561 return NULL;
10562 }
10563
10564
10565 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10566 PyObject *resultobj = 0;
10567 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10568 wxString result;
10569 void *argp1 = 0 ;
10570 int res1 = 0 ;
10571 PyObject *swig_obj[1] ;
10572
10573 if (!args) SWIG_fail;
10574 swig_obj[0] = args;
10575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10576 if (!SWIG_IsOK(res1)) {
10577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10578 }
10579 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10580 {
10581 PyThreadState* __tstate = wxPyBeginAllowThreads();
10582 result = (arg1)->GetPath();
10583 wxPyEndAllowThreads(__tstate);
10584 if (PyErr_Occurred()) SWIG_fail;
10585 }
10586 {
10587 #if wxUSE_UNICODE
10588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10589 #else
10590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10591 #endif
10592 }
10593 return resultobj;
10594 fail:
10595 return NULL;
10596 }
10597
10598
10599 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10600 PyObject *resultobj = 0;
10601 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10602 wxString *arg2 = 0 ;
10603 wxFSFile *result = 0 ;
10604 void *argp1 = 0 ;
10605 int res1 = 0 ;
10606 bool temp2 = false ;
10607 PyObject * obj0 = 0 ;
10608 PyObject * obj1 = 0 ;
10609 char * kwnames[] = {
10610 (char *) "self",(char *) "location", NULL
10611 };
10612
10613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10615 if (!SWIG_IsOK(res1)) {
10616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10617 }
10618 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10619 {
10620 arg2 = wxString_in_helper(obj1);
10621 if (arg2 == NULL) SWIG_fail;
10622 temp2 = true;
10623 }
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10627 wxPyEndAllowThreads(__tstate);
10628 if (PyErr_Occurred()) SWIG_fail;
10629 }
10630 {
10631 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10632 }
10633 {
10634 if (temp2)
10635 delete arg2;
10636 }
10637 return resultobj;
10638 fail:
10639 {
10640 if (temp2)
10641 delete arg2;
10642 }
10643 return NULL;
10644 }
10645
10646
10647 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10648 PyObject *resultobj = 0;
10649 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10650 wxString *arg2 = 0 ;
10651 int arg3 = (int) 0 ;
10652 wxString result;
10653 void *argp1 = 0 ;
10654 int res1 = 0 ;
10655 bool temp2 = false ;
10656 int val3 ;
10657 int ecode3 = 0 ;
10658 PyObject * obj0 = 0 ;
10659 PyObject * obj1 = 0 ;
10660 PyObject * obj2 = 0 ;
10661 char * kwnames[] = {
10662 (char *) "self",(char *) "spec",(char *) "flags", NULL
10663 };
10664
10665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10667 if (!SWIG_IsOK(res1)) {
10668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10669 }
10670 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10671 {
10672 arg2 = wxString_in_helper(obj1);
10673 if (arg2 == NULL) SWIG_fail;
10674 temp2 = true;
10675 }
10676 if (obj2) {
10677 ecode3 = SWIG_AsVal_int(obj2, &val3);
10678 if (!SWIG_IsOK(ecode3)) {
10679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10680 }
10681 arg3 = static_cast< int >(val3);
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 {
10690 #if wxUSE_UNICODE
10691 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10692 #else
10693 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10694 #endif
10695 }
10696 {
10697 if (temp2)
10698 delete arg2;
10699 }
10700 return resultobj;
10701 fail:
10702 {
10703 if (temp2)
10704 delete arg2;
10705 }
10706 return NULL;
10707 }
10708
10709
10710 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10711 PyObject *resultobj = 0;
10712 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10713 wxString result;
10714 void *argp1 = 0 ;
10715 int res1 = 0 ;
10716 PyObject *swig_obj[1] ;
10717
10718 if (!args) SWIG_fail;
10719 swig_obj[0] = args;
10720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10721 if (!SWIG_IsOK(res1)) {
10722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10723 }
10724 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 result = (arg1)->FindNext();
10728 wxPyEndAllowThreads(__tstate);
10729 if (PyErr_Occurred()) SWIG_fail;
10730 }
10731 {
10732 #if wxUSE_UNICODE
10733 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10734 #else
10735 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10736 #endif
10737 }
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = 0;
10746 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10747 int res1 = 0 ;
10748 PyObject * obj0 = 0 ;
10749 char * kwnames[] = {
10750 (char *) "handler", NULL
10751 };
10752
10753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10754 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10755 if (!SWIG_IsOK(res1)) {
10756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10757 }
10758 {
10759 PyThreadState* __tstate = wxPyBeginAllowThreads();
10760 wxFileSystem::AddHandler(arg1);
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 resultobj = SWIG_Py_Void();
10765 return resultobj;
10766 fail:
10767 return NULL;
10768 }
10769
10770
10771 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10772 PyObject *resultobj = 0;
10773
10774 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10775 {
10776 PyThreadState* __tstate = wxPyBeginAllowThreads();
10777 wxFileSystem::CleanUpHandlers();
10778 wxPyEndAllowThreads(__tstate);
10779 if (PyErr_Occurred()) SWIG_fail;
10780 }
10781 resultobj = SWIG_Py_Void();
10782 return resultobj;
10783 fail:
10784 return NULL;
10785 }
10786
10787
10788 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10789 PyObject *resultobj = 0;
10790 wxString *arg1 = 0 ;
10791 wxString result;
10792 bool temp1 = false ;
10793 PyObject * obj0 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "filename", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10799 {
10800 arg1 = wxString_in_helper(obj0);
10801 if (arg1 == NULL) SWIG_fail;
10802 temp1 = true;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
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 (temp1)
10819 delete arg1;
10820 }
10821 return resultobj;
10822 fail:
10823 {
10824 if (temp1)
10825 delete arg1;
10826 }
10827 return NULL;
10828 }
10829
10830
10831 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10832 PyObject *resultobj = 0;
10833 wxString *arg1 = 0 ;
10834 wxString result;
10835 bool temp1 = false ;
10836 PyObject * obj0 = 0 ;
10837 char * kwnames[] = {
10838 (char *) "url", NULL
10839 };
10840
10841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10842 {
10843 arg1 = wxString_in_helper(obj0);
10844 if (arg1 == NULL) SWIG_fail;
10845 temp1 = true;
10846 }
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 {
10854 #if wxUSE_UNICODE
10855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10856 #else
10857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10858 #endif
10859 }
10860 {
10861 if (temp1)
10862 delete arg1;
10863 }
10864 return resultobj;
10865 fail:
10866 {
10867 if (temp1)
10868 delete arg1;
10869 }
10870 return NULL;
10871 }
10872
10873
10874 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10875 PyObject *obj;
10876 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10877 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10878 return SWIG_Py_Void();
10879 }
10880
10881 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10882 return SWIG_Python_InitShadowInstance(args);
10883 }
10884
10885 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10886 PyObject *resultobj = 0;
10887 wxInternetFSHandler *result = 0 ;
10888
10889 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj = 0;
10905 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10906 wxString *arg2 = 0 ;
10907 bool result;
10908 void *argp1 = 0 ;
10909 int res1 = 0 ;
10910 bool temp2 = false ;
10911 PyObject * obj0 = 0 ;
10912 PyObject * obj1 = 0 ;
10913 char * kwnames[] = {
10914 (char *) "self",(char *) "location", NULL
10915 };
10916
10917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10919 if (!SWIG_IsOK(res1)) {
10920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10921 }
10922 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10923 {
10924 arg2 = wxString_in_helper(obj1);
10925 if (arg2 == NULL) SWIG_fail;
10926 temp2 = true;
10927 }
10928 {
10929 PyThreadState* __tstate = wxPyBeginAllowThreads();
10930 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10931 wxPyEndAllowThreads(__tstate);
10932 if (PyErr_Occurred()) SWIG_fail;
10933 }
10934 {
10935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10936 }
10937 {
10938 if (temp2)
10939 delete arg2;
10940 }
10941 return resultobj;
10942 fail:
10943 {
10944 if (temp2)
10945 delete arg2;
10946 }
10947 return NULL;
10948 }
10949
10950
10951 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10952 PyObject *resultobj = 0;
10953 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10954 wxFileSystem *arg2 = 0 ;
10955 wxString *arg3 = 0 ;
10956 wxFSFile *result = 0 ;
10957 void *argp1 = 0 ;
10958 int res1 = 0 ;
10959 void *argp2 = 0 ;
10960 int res2 = 0 ;
10961 bool temp3 = false ;
10962 PyObject * obj0 = 0 ;
10963 PyObject * obj1 = 0 ;
10964 PyObject * obj2 = 0 ;
10965 char * kwnames[] = {
10966 (char *) "self",(char *) "fs",(char *) "location", NULL
10967 };
10968
10969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10971 if (!SWIG_IsOK(res1)) {
10972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10973 }
10974 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10976 if (!SWIG_IsOK(res2)) {
10977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10978 }
10979 if (!argp2) {
10980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10981 }
10982 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10983 {
10984 arg3 = wxString_in_helper(obj2);
10985 if (arg3 == NULL) SWIG_fail;
10986 temp3 = true;
10987 }
10988 {
10989 PyThreadState* __tstate = wxPyBeginAllowThreads();
10990 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 {
10995 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10996 }
10997 {
10998 if (temp3)
10999 delete arg3;
11000 }
11001 return resultobj;
11002 fail:
11003 {
11004 if (temp3)
11005 delete arg3;
11006 }
11007 return NULL;
11008 }
11009
11010
11011 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11012 PyObject *obj;
11013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11014 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11015 return SWIG_Py_Void();
11016 }
11017
11018 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11019 return SWIG_Python_InitShadowInstance(args);
11020 }
11021
11022 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11023 PyObject *resultobj = 0;
11024 wxZipFSHandler *result = 0 ;
11025
11026 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = (wxZipFSHandler *)new wxZipFSHandler();
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11043 wxString *arg2 = 0 ;
11044 bool result;
11045 void *argp1 = 0 ;
11046 int res1 = 0 ;
11047 bool temp2 = false ;
11048 PyObject * obj0 = 0 ;
11049 PyObject * obj1 = 0 ;
11050 char * kwnames[] = {
11051 (char *) "self",(char *) "location", NULL
11052 };
11053
11054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11056 if (!SWIG_IsOK(res1)) {
11057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11058 }
11059 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11060 {
11061 arg2 = wxString_in_helper(obj1);
11062 if (arg2 == NULL) SWIG_fail;
11063 temp2 = true;
11064 }
11065 {
11066 PyThreadState* __tstate = wxPyBeginAllowThreads();
11067 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11068 wxPyEndAllowThreads(__tstate);
11069 if (PyErr_Occurred()) SWIG_fail;
11070 }
11071 {
11072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11073 }
11074 {
11075 if (temp2)
11076 delete arg2;
11077 }
11078 return resultobj;
11079 fail:
11080 {
11081 if (temp2)
11082 delete arg2;
11083 }
11084 return NULL;
11085 }
11086
11087
11088 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11089 PyObject *resultobj = 0;
11090 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11091 wxFileSystem *arg2 = 0 ;
11092 wxString *arg3 = 0 ;
11093 wxFSFile *result = 0 ;
11094 void *argp1 = 0 ;
11095 int res1 = 0 ;
11096 void *argp2 = 0 ;
11097 int res2 = 0 ;
11098 bool temp3 = false ;
11099 PyObject * obj0 = 0 ;
11100 PyObject * obj1 = 0 ;
11101 PyObject * obj2 = 0 ;
11102 char * kwnames[] = {
11103 (char *) "self",(char *) "fs",(char *) "location", NULL
11104 };
11105
11106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11108 if (!SWIG_IsOK(res1)) {
11109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11110 }
11111 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11113 if (!SWIG_IsOK(res2)) {
11114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11115 }
11116 if (!argp2) {
11117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11118 }
11119 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11120 {
11121 arg3 = wxString_in_helper(obj2);
11122 if (arg3 == NULL) SWIG_fail;
11123 temp3 = true;
11124 }
11125 {
11126 PyThreadState* __tstate = wxPyBeginAllowThreads();
11127 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11128 wxPyEndAllowThreads(__tstate);
11129 if (PyErr_Occurred()) SWIG_fail;
11130 }
11131 {
11132 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11133 }
11134 {
11135 if (temp3)
11136 delete arg3;
11137 }
11138 return resultobj;
11139 fail:
11140 {
11141 if (temp3)
11142 delete arg3;
11143 }
11144 return NULL;
11145 }
11146
11147
11148 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj = 0;
11150 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11151 wxString *arg2 = 0 ;
11152 int arg3 = (int) 0 ;
11153 wxString result;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 bool temp2 = false ;
11157 int val3 ;
11158 int ecode3 = 0 ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char * kwnames[] = {
11163 (char *) "self",(char *) "spec",(char *) "flags", NULL
11164 };
11165
11166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11168 if (!SWIG_IsOK(res1)) {
11169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11170 }
11171 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11172 {
11173 arg2 = wxString_in_helper(obj1);
11174 if (arg2 == NULL) SWIG_fail;
11175 temp2 = true;
11176 }
11177 if (obj2) {
11178 ecode3 = SWIG_AsVal_int(obj2, &val3);
11179 if (!SWIG_IsOK(ecode3)) {
11180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11181 }
11182 arg3 = static_cast< int >(val3);
11183 }
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 #if wxUSE_UNICODE
11192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11193 #else
11194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11195 #endif
11196 }
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return resultobj;
11202 fail:
11203 {
11204 if (temp2)
11205 delete arg2;
11206 }
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11214 wxString result;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 PyObject *swig_obj[1] ;
11218
11219 if (!args) SWIG_fail;
11220 swig_obj[0] = args;
11221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11224 }
11225 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 result = (arg1)->FindNext();
11229 wxPyEndAllowThreads(__tstate);
11230 if (PyErr_Occurred()) SWIG_fail;
11231 }
11232 {
11233 #if wxUSE_UNICODE
11234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11235 #else
11236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11237 #endif
11238 }
11239 return resultobj;
11240 fail:
11241 return NULL;
11242 }
11243
11244
11245 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11246 PyObject *obj;
11247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11248 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11249 return SWIG_Py_Void();
11250 }
11251
11252 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11253 return SWIG_Python_InitShadowInstance(args);
11254 }
11255
11256 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj = 0;
11258 wxString *arg1 = 0 ;
11259 wxImage *arg2 = 0 ;
11260 long arg3 ;
11261 bool temp1 = false ;
11262 void *argp2 = 0 ;
11263 int res2 = 0 ;
11264 long val3 ;
11265 int ecode3 = 0 ;
11266 PyObject * obj0 = 0 ;
11267 PyObject * obj1 = 0 ;
11268 PyObject * obj2 = 0 ;
11269 char * kwnames[] = {
11270 (char *) "filename",(char *) "image",(char *) "type", NULL
11271 };
11272
11273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11274 {
11275 arg1 = wxString_in_helper(obj0);
11276 if (arg1 == NULL) SWIG_fail;
11277 temp1 = true;
11278 }
11279 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11280 if (!SWIG_IsOK(res2)) {
11281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11282 }
11283 if (!argp2) {
11284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11285 }
11286 arg2 = reinterpret_cast< wxImage * >(argp2);
11287 ecode3 = SWIG_AsVal_long(obj2, &val3);
11288 if (!SWIG_IsOK(ecode3)) {
11289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11290 }
11291 arg3 = static_cast< long >(val3);
11292 {
11293 PyThreadState* __tstate = wxPyBeginAllowThreads();
11294 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11295 wxPyEndAllowThreads(__tstate);
11296 if (PyErr_Occurred()) SWIG_fail;
11297 }
11298 resultobj = SWIG_Py_Void();
11299 {
11300 if (temp1)
11301 delete arg1;
11302 }
11303 return resultobj;
11304 fail:
11305 {
11306 if (temp1)
11307 delete arg1;
11308 }
11309 return NULL;
11310 }
11311
11312
11313 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11314 PyObject *resultobj = 0;
11315 wxString *arg1 = 0 ;
11316 wxBitmap *arg2 = 0 ;
11317 long arg3 ;
11318 bool temp1 = false ;
11319 void *argp2 = 0 ;
11320 int res2 = 0 ;
11321 long val3 ;
11322 int ecode3 = 0 ;
11323 PyObject * obj0 = 0 ;
11324 PyObject * obj1 = 0 ;
11325 PyObject * obj2 = 0 ;
11326 char * kwnames[] = {
11327 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11328 };
11329
11330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11331 {
11332 arg1 = wxString_in_helper(obj0);
11333 if (arg1 == NULL) SWIG_fail;
11334 temp1 = true;
11335 }
11336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11337 if (!SWIG_IsOK(res2)) {
11338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11339 }
11340 if (!argp2) {
11341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11342 }
11343 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11344 ecode3 = SWIG_AsVal_long(obj2, &val3);
11345 if (!SWIG_IsOK(ecode3)) {
11346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11347 }
11348 arg3 = static_cast< long >(val3);
11349 {
11350 PyThreadState* __tstate = wxPyBeginAllowThreads();
11351 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11352 wxPyEndAllowThreads(__tstate);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 resultobj = SWIG_Py_Void();
11356 {
11357 if (temp1)
11358 delete arg1;
11359 }
11360 return resultobj;
11361 fail:
11362 {
11363 if (temp1)
11364 delete arg1;
11365 }
11366 return NULL;
11367 }
11368
11369
11370 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11371 PyObject *resultobj = 0;
11372 wxString *arg1 = 0 ;
11373 PyObject *arg2 = (PyObject *) 0 ;
11374 bool temp1 = false ;
11375 PyObject * obj0 = 0 ;
11376 PyObject * obj1 = 0 ;
11377 char * kwnames[] = {
11378 (char *) "filename",(char *) "data", NULL
11379 };
11380
11381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11382 {
11383 arg1 = wxString_in_helper(obj0);
11384 if (arg1 == NULL) SWIG_fail;
11385 temp1 = true;
11386 }
11387 arg2 = obj1;
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11391 wxPyEndAllowThreads(__tstate);
11392 if (PyErr_Occurred()) SWIG_fail;
11393 }
11394 resultobj = SWIG_Py_Void();
11395 {
11396 if (temp1)
11397 delete arg1;
11398 }
11399 return resultobj;
11400 fail:
11401 {
11402 if (temp1)
11403 delete arg1;
11404 }
11405 return NULL;
11406 }
11407
11408
11409 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11410 PyObject *resultobj = 0;
11411 wxMemoryFSHandler *result = 0 ;
11412
11413 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11414 {
11415 PyThreadState* __tstate = wxPyBeginAllowThreads();
11416 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11417 wxPyEndAllowThreads(__tstate);
11418 if (PyErr_Occurred()) SWIG_fail;
11419 }
11420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11421 return resultobj;
11422 fail:
11423 return NULL;
11424 }
11425
11426
11427 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11428 PyObject *resultobj = 0;
11429 wxString *arg1 = 0 ;
11430 bool temp1 = false ;
11431 PyObject * obj0 = 0 ;
11432 char * kwnames[] = {
11433 (char *) "filename", NULL
11434 };
11435
11436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11437 {
11438 arg1 = wxString_in_helper(obj0);
11439 if (arg1 == NULL) SWIG_fail;
11440 temp1 = true;
11441 }
11442 {
11443 PyThreadState* __tstate = wxPyBeginAllowThreads();
11444 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11445 wxPyEndAllowThreads(__tstate);
11446 if (PyErr_Occurred()) SWIG_fail;
11447 }
11448 resultobj = SWIG_Py_Void();
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return resultobj;
11454 fail:
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return NULL;
11460 }
11461
11462
11463 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj = 0;
11465 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11466 wxString *arg2 = 0 ;
11467 bool result;
11468 void *argp1 = 0 ;
11469 int res1 = 0 ;
11470 bool temp2 = false ;
11471 PyObject * obj0 = 0 ;
11472 PyObject * obj1 = 0 ;
11473 char * kwnames[] = {
11474 (char *) "self",(char *) "location", NULL
11475 };
11476
11477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11479 if (!SWIG_IsOK(res1)) {
11480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11481 }
11482 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11483 {
11484 arg2 = wxString_in_helper(obj1);
11485 if (arg2 == NULL) SWIG_fail;
11486 temp2 = true;
11487 }
11488 {
11489 PyThreadState* __tstate = wxPyBeginAllowThreads();
11490 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 {
11495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11496 }
11497 {
11498 if (temp2)
11499 delete arg2;
11500 }
11501 return resultobj;
11502 fail:
11503 {
11504 if (temp2)
11505 delete arg2;
11506 }
11507 return NULL;
11508 }
11509
11510
11511 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11512 PyObject *resultobj = 0;
11513 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11514 wxFileSystem *arg2 = 0 ;
11515 wxString *arg3 = 0 ;
11516 wxFSFile *result = 0 ;
11517 void *argp1 = 0 ;
11518 int res1 = 0 ;
11519 void *argp2 = 0 ;
11520 int res2 = 0 ;
11521 bool temp3 = false ;
11522 PyObject * obj0 = 0 ;
11523 PyObject * obj1 = 0 ;
11524 PyObject * obj2 = 0 ;
11525 char * kwnames[] = {
11526 (char *) "self",(char *) "fs",(char *) "location", NULL
11527 };
11528
11529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11533 }
11534 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11535 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11536 if (!SWIG_IsOK(res2)) {
11537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11538 }
11539 if (!argp2) {
11540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11541 }
11542 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11543 {
11544 arg3 = wxString_in_helper(obj2);
11545 if (arg3 == NULL) SWIG_fail;
11546 temp3 = true;
11547 }
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11556 }
11557 {
11558 if (temp3)
11559 delete arg3;
11560 }
11561 return resultobj;
11562 fail:
11563 {
11564 if (temp3)
11565 delete arg3;
11566 }
11567 return NULL;
11568 }
11569
11570
11571 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11572 PyObject *resultobj = 0;
11573 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11574 wxString *arg2 = 0 ;
11575 int arg3 = (int) 0 ;
11576 wxString result;
11577 void *argp1 = 0 ;
11578 int res1 = 0 ;
11579 bool temp2 = false ;
11580 int val3 ;
11581 int ecode3 = 0 ;
11582 PyObject * obj0 = 0 ;
11583 PyObject * obj1 = 0 ;
11584 PyObject * obj2 = 0 ;
11585 char * kwnames[] = {
11586 (char *) "self",(char *) "spec",(char *) "flags", NULL
11587 };
11588
11589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11591 if (!SWIG_IsOK(res1)) {
11592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11593 }
11594 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11595 {
11596 arg2 = wxString_in_helper(obj1);
11597 if (arg2 == NULL) SWIG_fail;
11598 temp2 = true;
11599 }
11600 if (obj2) {
11601 ecode3 = SWIG_AsVal_int(obj2, &val3);
11602 if (!SWIG_IsOK(ecode3)) {
11603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11604 }
11605 arg3 = static_cast< int >(val3);
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 #if wxUSE_UNICODE
11615 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11616 #else
11617 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11618 #endif
11619 }
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return resultobj;
11625 fail:
11626 {
11627 if (temp2)
11628 delete arg2;
11629 }
11630 return NULL;
11631 }
11632
11633
11634 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11635 PyObject *resultobj = 0;
11636 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11637 wxString result;
11638 void *argp1 = 0 ;
11639 int res1 = 0 ;
11640 PyObject *swig_obj[1] ;
11641
11642 if (!args) SWIG_fail;
11643 swig_obj[0] = args;
11644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11645 if (!SWIG_IsOK(res1)) {
11646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11647 }
11648 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (arg1)->FindNext();
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 {
11656 #if wxUSE_UNICODE
11657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11658 #else
11659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11660 #endif
11661 }
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *obj;
11670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11671 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11672 return SWIG_Py_Void();
11673 }
11674
11675 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11676 return SWIG_Python_InitShadowInstance(args);
11677 }
11678
11679 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 PyObject *resultobj = 0;
11681 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11682 wxString result;
11683 void *argp1 = 0 ;
11684 int res1 = 0 ;
11685 PyObject *swig_obj[1] ;
11686
11687 if (!args) SWIG_fail;
11688 swig_obj[0] = args;
11689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11690 if (!SWIG_IsOK(res1)) {
11691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11692 }
11693 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11694 {
11695 PyThreadState* __tstate = wxPyBeginAllowThreads();
11696 result = (arg1)->GetName();
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 {
11701 #if wxUSE_UNICODE
11702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11703 #else
11704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11705 #endif
11706 }
11707 return resultobj;
11708 fail:
11709 return NULL;
11710 }
11711
11712
11713 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11714 PyObject *resultobj = 0;
11715 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11716 wxString result;
11717 void *argp1 = 0 ;
11718 int res1 = 0 ;
11719 PyObject *swig_obj[1] ;
11720
11721 if (!args) SWIG_fail;
11722 swig_obj[0] = args;
11723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11724 if (!SWIG_IsOK(res1)) {
11725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11726 }
11727 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 result = (arg1)->GetExtension();
11731 wxPyEndAllowThreads(__tstate);
11732 if (PyErr_Occurred()) SWIG_fail;
11733 }
11734 {
11735 #if wxUSE_UNICODE
11736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11737 #else
11738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11739 #endif
11740 }
11741 return resultobj;
11742 fail:
11743 return NULL;
11744 }
11745
11746
11747 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11748 PyObject *resultobj = 0;
11749 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11750 long result;
11751 void *argp1 = 0 ;
11752 int res1 = 0 ;
11753 PyObject *swig_obj[1] ;
11754
11755 if (!args) SWIG_fail;
11756 swig_obj[0] = args;
11757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11758 if (!SWIG_IsOK(res1)) {
11759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11760 }
11761 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11762 {
11763 PyThreadState* __tstate = wxPyBeginAllowThreads();
11764 result = (long)(arg1)->GetType();
11765 wxPyEndAllowThreads(__tstate);
11766 if (PyErr_Occurred()) SWIG_fail;
11767 }
11768 resultobj = SWIG_From_long(static_cast< long >(result));
11769 return resultobj;
11770 fail:
11771 return NULL;
11772 }
11773
11774
11775 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11776 PyObject *resultobj = 0;
11777 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11778 wxString result;
11779 void *argp1 = 0 ;
11780 int res1 = 0 ;
11781 PyObject *swig_obj[1] ;
11782
11783 if (!args) SWIG_fail;
11784 swig_obj[0] = args;
11785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11786 if (!SWIG_IsOK(res1)) {
11787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11788 }
11789 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11790 {
11791 PyThreadState* __tstate = wxPyBeginAllowThreads();
11792 result = (arg1)->GetMimeType();
11793 wxPyEndAllowThreads(__tstate);
11794 if (PyErr_Occurred()) SWIG_fail;
11795 }
11796 {
11797 #if wxUSE_UNICODE
11798 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11799 #else
11800 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11801 #endif
11802 }
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj = 0;
11811 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11812 wxString *arg2 = 0 ;
11813 bool result;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 bool temp2 = false ;
11817 PyObject * obj0 = 0 ;
11818 PyObject * obj1 = 0 ;
11819 char * kwnames[] = {
11820 (char *) "self",(char *) "name", NULL
11821 };
11822
11823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11825 if (!SWIG_IsOK(res1)) {
11826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11827 }
11828 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11829 {
11830 arg2 = wxString_in_helper(obj1);
11831 if (arg2 == NULL) SWIG_fail;
11832 temp2 = true;
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 {
11841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11842 }
11843 {
11844 if (temp2)
11845 delete arg2;
11846 }
11847 return resultobj;
11848 fail:
11849 {
11850 if (temp2)
11851 delete arg2;
11852 }
11853 return NULL;
11854 }
11855
11856
11857 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11858 PyObject *resultobj = 0;
11859 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11860 wxString *arg2 = 0 ;
11861 void *argp1 = 0 ;
11862 int res1 = 0 ;
11863 bool temp2 = false ;
11864 PyObject * obj0 = 0 ;
11865 PyObject * obj1 = 0 ;
11866 char * kwnames[] = {
11867 (char *) "self",(char *) "name", NULL
11868 };
11869
11870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11872 if (!SWIG_IsOK(res1)) {
11873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11874 }
11875 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11876 {
11877 arg2 = wxString_in_helper(obj1);
11878 if (arg2 == NULL) SWIG_fail;
11879 temp2 = true;
11880 }
11881 {
11882 PyThreadState* __tstate = wxPyBeginAllowThreads();
11883 (arg1)->SetName((wxString const &)*arg2);
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 resultobj = SWIG_Py_Void();
11888 {
11889 if (temp2)
11890 delete arg2;
11891 }
11892 return resultobj;
11893 fail:
11894 {
11895 if (temp2)
11896 delete arg2;
11897 }
11898 return NULL;
11899 }
11900
11901
11902 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11903 PyObject *resultobj = 0;
11904 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11905 wxString *arg2 = 0 ;
11906 void *argp1 = 0 ;
11907 int res1 = 0 ;
11908 bool temp2 = false ;
11909 PyObject * obj0 = 0 ;
11910 PyObject * obj1 = 0 ;
11911 char * kwnames[] = {
11912 (char *) "self",(char *) "extension", NULL
11913 };
11914
11915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11917 if (!SWIG_IsOK(res1)) {
11918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11919 }
11920 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11921 {
11922 arg2 = wxString_in_helper(obj1);
11923 if (arg2 == NULL) SWIG_fail;
11924 temp2 = true;
11925 }
11926 {
11927 PyThreadState* __tstate = wxPyBeginAllowThreads();
11928 (arg1)->SetExtension((wxString const &)*arg2);
11929 wxPyEndAllowThreads(__tstate);
11930 if (PyErr_Occurred()) SWIG_fail;
11931 }
11932 resultobj = SWIG_Py_Void();
11933 {
11934 if (temp2)
11935 delete arg2;
11936 }
11937 return resultobj;
11938 fail:
11939 {
11940 if (temp2)
11941 delete arg2;
11942 }
11943 return NULL;
11944 }
11945
11946
11947 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj = 0;
11949 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11950 long arg2 ;
11951 void *argp1 = 0 ;
11952 int res1 = 0 ;
11953 long val2 ;
11954 int ecode2 = 0 ;
11955 PyObject * obj0 = 0 ;
11956 PyObject * obj1 = 0 ;
11957 char * kwnames[] = {
11958 (char *) "self",(char *) "type", NULL
11959 };
11960
11961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11963 if (!SWIG_IsOK(res1)) {
11964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11965 }
11966 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11967 ecode2 = SWIG_AsVal_long(obj1, &val2);
11968 if (!SWIG_IsOK(ecode2)) {
11969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11970 }
11971 arg2 = static_cast< long >(val2);
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 (arg1)->SetType(arg2);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 resultobj = SWIG_Py_Void();
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11986 PyObject *resultobj = 0;
11987 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11988 wxString *arg2 = 0 ;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 bool temp2 = false ;
11992 PyObject * obj0 = 0 ;
11993 PyObject * obj1 = 0 ;
11994 char * kwnames[] = {
11995 (char *) "self",(char *) "mimetype", NULL
11996 };
11997
11998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12000 if (!SWIG_IsOK(res1)) {
12001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12002 }
12003 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12004 {
12005 arg2 = wxString_in_helper(obj1);
12006 if (arg2 == NULL) SWIG_fail;
12007 temp2 = true;
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 (arg1)->SetMimeType((wxString const &)*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 resultobj = SWIG_Py_Void();
12016 {
12017 if (temp2)
12018 delete arg2;
12019 }
12020 return resultobj;
12021 fail:
12022 {
12023 if (temp2)
12024 delete arg2;
12025 }
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12031 PyObject *obj;
12032 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12033 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12034 return SWIG_Py_Void();
12035 }
12036
12037 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12038 PyObject *resultobj = 0;
12039 wxPyImageHandler *result = 0 ;
12040
12041 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12042 {
12043 PyThreadState* __tstate = wxPyBeginAllowThreads();
12044 result = (wxPyImageHandler *)new wxPyImageHandler();
12045 wxPyEndAllowThreads(__tstate);
12046 if (PyErr_Occurred()) SWIG_fail;
12047 }
12048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12049 return resultobj;
12050 fail:
12051 return NULL;
12052 }
12053
12054
12055 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12056 PyObject *resultobj = 0;
12057 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12058 PyObject *arg2 = (PyObject *) 0 ;
12059 void *argp1 = 0 ;
12060 int res1 = 0 ;
12061 PyObject * obj0 = 0 ;
12062 PyObject * obj1 = 0 ;
12063 char * kwnames[] = {
12064 (char *) "self",(char *) "self", NULL
12065 };
12066
12067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12069 if (!SWIG_IsOK(res1)) {
12070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12071 }
12072 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12073 arg2 = obj1;
12074 {
12075 PyThreadState* __tstate = wxPyBeginAllowThreads();
12076 (arg1)->_SetSelf(arg2);
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 resultobj = SWIG_Py_Void();
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12088 PyObject *obj;
12089 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12090 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12091 return SWIG_Py_Void();
12092 }
12093
12094 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12095 return SWIG_Python_InitShadowInstance(args);
12096 }
12097
12098 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12099 PyObject *resultobj = 0;
12100 wxImageHistogram *result = 0 ;
12101
12102 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (wxImageHistogram *)new wxImageHistogram();
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12117 PyObject *resultobj = 0;
12118 byte arg1 ;
12119 byte arg2 ;
12120 byte arg3 ;
12121 unsigned long result;
12122 unsigned char val1 ;
12123 int ecode1 = 0 ;
12124 unsigned char val2 ;
12125 int ecode2 = 0 ;
12126 unsigned char val3 ;
12127 int ecode3 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 PyObject * obj2 = 0 ;
12131 char * kwnames[] = {
12132 (char *) "r",(char *) "g",(char *) "b", NULL
12133 };
12134
12135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12136 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12137 if (!SWIG_IsOK(ecode1)) {
12138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12139 }
12140 arg1 = static_cast< byte >(val1);
12141 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12142 if (!SWIG_IsOK(ecode2)) {
12143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12144 }
12145 arg2 = static_cast< byte >(val2);
12146 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12147 if (!SWIG_IsOK(ecode3)) {
12148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12149 }
12150 arg3 = static_cast< byte >(val3);
12151 {
12152 PyThreadState* __tstate = wxPyBeginAllowThreads();
12153 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12154 wxPyEndAllowThreads(__tstate);
12155 if (PyErr_Occurred()) SWIG_fail;
12156 }
12157 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12158 return resultobj;
12159 fail:
12160 return NULL;
12161 }
12162
12163
12164 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12165 PyObject *resultobj = 0;
12166 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12167 byte *arg2 = (byte *) 0 ;
12168 byte *arg3 = (byte *) 0 ;
12169 byte *arg4 = (byte *) 0 ;
12170 byte arg5 = (byte) 1 ;
12171 byte arg6 = (byte) 0 ;
12172 byte arg7 = (byte) 0 ;
12173 bool result;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 byte temp2 ;
12177 int res2 = SWIG_TMPOBJ ;
12178 byte temp3 ;
12179 int res3 = SWIG_TMPOBJ ;
12180 byte temp4 ;
12181 int res4 = SWIG_TMPOBJ ;
12182 unsigned char val5 ;
12183 int ecode5 = 0 ;
12184 unsigned char val6 ;
12185 int ecode6 = 0 ;
12186 unsigned char val7 ;
12187 int ecode7 = 0 ;
12188 PyObject * obj0 = 0 ;
12189 PyObject * obj1 = 0 ;
12190 PyObject * obj2 = 0 ;
12191 PyObject * obj3 = 0 ;
12192 char * kwnames[] = {
12193 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12194 };
12195
12196 arg2 = &temp2;
12197 arg3 = &temp3;
12198 arg4 = &temp4;
12199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12201 if (!SWIG_IsOK(res1)) {
12202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12203 }
12204 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12205 if (obj1) {
12206 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12207 if (!SWIG_IsOK(ecode5)) {
12208 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12209 }
12210 arg5 = static_cast< byte >(val5);
12211 }
12212 if (obj2) {
12213 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12214 if (!SWIG_IsOK(ecode6)) {
12215 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12216 }
12217 arg6 = static_cast< byte >(val6);
12218 }
12219 if (obj3) {
12220 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12221 if (!SWIG_IsOK(ecode7)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12223 }
12224 arg7 = static_cast< byte >(val7);
12225 }
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 {
12233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12234 }
12235 if (SWIG_IsTmpObj(res2)) {
12236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12237 } else {
12238 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12240 }
12241 if (SWIG_IsTmpObj(res3)) {
12242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12243 } else {
12244 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12246 }
12247 if (SWIG_IsTmpObj(res4)) {
12248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12249 } else {
12250 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12252 }
12253 return resultobj;
12254 fail:
12255 return NULL;
12256 }
12257
12258
12259 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12260 PyObject *resultobj = 0;
12261 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12262 unsigned long arg2 ;
12263 unsigned long result;
12264 void *argp1 = 0 ;
12265 int res1 = 0 ;
12266 unsigned long val2 ;
12267 int ecode2 = 0 ;
12268 PyObject * obj0 = 0 ;
12269 PyObject * obj1 = 0 ;
12270 char * kwnames[] = {
12271 (char *) "self",(char *) "key", NULL
12272 };
12273
12274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12276 if (!SWIG_IsOK(res1)) {
12277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12278 }
12279 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12280 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12281 if (!SWIG_IsOK(ecode2)) {
12282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12283 }
12284 arg2 = static_cast< unsigned long >(val2);
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12299 PyObject *resultobj = 0;
12300 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12301 byte arg2 ;
12302 byte arg3 ;
12303 byte arg4 ;
12304 unsigned long result;
12305 void *argp1 = 0 ;
12306 int res1 = 0 ;
12307 unsigned char val2 ;
12308 int ecode2 = 0 ;
12309 unsigned char val3 ;
12310 int ecode3 = 0 ;
12311 unsigned char val4 ;
12312 int ecode4 = 0 ;
12313 PyObject * obj0 = 0 ;
12314 PyObject * obj1 = 0 ;
12315 PyObject * obj2 = 0 ;
12316 PyObject * obj3 = 0 ;
12317 char * kwnames[] = {
12318 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12319 };
12320
12321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12323 if (!SWIG_IsOK(res1)) {
12324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12325 }
12326 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12327 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12328 if (!SWIG_IsOK(ecode2)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12330 }
12331 arg2 = static_cast< byte >(val2);
12332 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12333 if (!SWIG_IsOK(ecode3)) {
12334 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12335 }
12336 arg3 = static_cast< byte >(val3);
12337 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12338 if (!SWIG_IsOK(ecode4)) {
12339 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12340 }
12341 arg4 = static_cast< byte >(val4);
12342 {
12343 PyThreadState* __tstate = wxPyBeginAllowThreads();
12344 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj = 0;
12357 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12358 wxColour *arg2 = 0 ;
12359 unsigned long result;
12360 void *argp1 = 0 ;
12361 int res1 = 0 ;
12362 wxColour temp2 ;
12363 PyObject * obj0 = 0 ;
12364 PyObject * obj1 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "colour", NULL
12367 };
12368
12369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12371 if (!SWIG_IsOK(res1)) {
12372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12373 }
12374 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12375 {
12376 arg2 = &temp2;
12377 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12378 }
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12382 wxPyEndAllowThreads(__tstate);
12383 if (PyErr_Occurred()) SWIG_fail;
12384 }
12385 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12386 return resultobj;
12387 fail:
12388 return NULL;
12389 }
12390
12391
12392 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12393 PyObject *obj;
12394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12395 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12396 return SWIG_Py_Void();
12397 }
12398
12399 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12400 return SWIG_Python_InitShadowInstance(args);
12401 }
12402
12403 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12404 PyObject *resultobj = 0;
12405 byte arg1 = (byte) 0 ;
12406 byte arg2 = (byte) 0 ;
12407 byte arg3 = (byte) 0 ;
12408 wxImage_RGBValue *result = 0 ;
12409 unsigned char val1 ;
12410 int ecode1 = 0 ;
12411 unsigned char val2 ;
12412 int ecode2 = 0 ;
12413 unsigned char val3 ;
12414 int ecode3 = 0 ;
12415 PyObject * obj0 = 0 ;
12416 PyObject * obj1 = 0 ;
12417 PyObject * obj2 = 0 ;
12418 char * kwnames[] = {
12419 (char *) "r",(char *) "g",(char *) "b", NULL
12420 };
12421
12422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12423 if (obj0) {
12424 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12425 if (!SWIG_IsOK(ecode1)) {
12426 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12427 }
12428 arg1 = static_cast< byte >(val1);
12429 }
12430 if (obj1) {
12431 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12432 if (!SWIG_IsOK(ecode2)) {
12433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12434 }
12435 arg2 = static_cast< byte >(val2);
12436 }
12437 if (obj2) {
12438 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12439 if (!SWIG_IsOK(ecode3)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12441 }
12442 arg3 = static_cast< byte >(val3);
12443 }
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12458 PyObject *resultobj = 0;
12459 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12460 byte arg2 ;
12461 void *argp1 = 0 ;
12462 int res1 = 0 ;
12463 unsigned char val2 ;
12464 int ecode2 = 0 ;
12465 PyObject *swig_obj[2] ;
12466
12467 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12469 if (!SWIG_IsOK(res1)) {
12470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12471 }
12472 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12473 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12474 if (!SWIG_IsOK(ecode2)) {
12475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12476 }
12477 arg2 = static_cast< byte >(val2);
12478 if (arg1) (arg1)->red = arg2;
12479
12480 resultobj = SWIG_Py_Void();
12481 return resultobj;
12482 fail:
12483 return NULL;
12484 }
12485
12486
12487 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12488 PyObject *resultobj = 0;
12489 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12490 byte result;
12491 void *argp1 = 0 ;
12492 int res1 = 0 ;
12493 PyObject *swig_obj[1] ;
12494
12495 if (!args) SWIG_fail;
12496 swig_obj[0] = args;
12497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12498 if (!SWIG_IsOK(res1)) {
12499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12500 }
12501 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12502 result = (byte) ((arg1)->red);
12503 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12504 return resultobj;
12505 fail:
12506 return NULL;
12507 }
12508
12509
12510 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12511 PyObject *resultobj = 0;
12512 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12513 byte arg2 ;
12514 void *argp1 = 0 ;
12515 int res1 = 0 ;
12516 unsigned char val2 ;
12517 int ecode2 = 0 ;
12518 PyObject *swig_obj[2] ;
12519
12520 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12522 if (!SWIG_IsOK(res1)) {
12523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12524 }
12525 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12526 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12527 if (!SWIG_IsOK(ecode2)) {
12528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12529 }
12530 arg2 = static_cast< byte >(val2);
12531 if (arg1) (arg1)->green = arg2;
12532
12533 resultobj = SWIG_Py_Void();
12534 return resultobj;
12535 fail:
12536 return NULL;
12537 }
12538
12539
12540 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12541 PyObject *resultobj = 0;
12542 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12543 byte result;
12544 void *argp1 = 0 ;
12545 int res1 = 0 ;
12546 PyObject *swig_obj[1] ;
12547
12548 if (!args) SWIG_fail;
12549 swig_obj[0] = args;
12550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12551 if (!SWIG_IsOK(res1)) {
12552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12553 }
12554 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12555 result = (byte) ((arg1)->green);
12556 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12564 PyObject *resultobj = 0;
12565 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12566 byte arg2 ;
12567 void *argp1 = 0 ;
12568 int res1 = 0 ;
12569 unsigned char val2 ;
12570 int ecode2 = 0 ;
12571 PyObject *swig_obj[2] ;
12572
12573 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12575 if (!SWIG_IsOK(res1)) {
12576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12577 }
12578 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12579 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12580 if (!SWIG_IsOK(ecode2)) {
12581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12582 }
12583 arg2 = static_cast< byte >(val2);
12584 if (arg1) (arg1)->blue = arg2;
12585
12586 resultobj = SWIG_Py_Void();
12587 return resultobj;
12588 fail:
12589 return NULL;
12590 }
12591
12592
12593 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12594 PyObject *resultobj = 0;
12595 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12596 byte result;
12597 void *argp1 = 0 ;
12598 int res1 = 0 ;
12599 PyObject *swig_obj[1] ;
12600
12601 if (!args) SWIG_fail;
12602 swig_obj[0] = args;
12603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12604 if (!SWIG_IsOK(res1)) {
12605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12606 }
12607 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12608 result = (byte) ((arg1)->blue);
12609 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12610 return resultobj;
12611 fail:
12612 return NULL;
12613 }
12614
12615
12616 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12617 PyObject *obj;
12618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12619 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12620 return SWIG_Py_Void();
12621 }
12622
12623 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12624 return SWIG_Python_InitShadowInstance(args);
12625 }
12626
12627 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12628 PyObject *resultobj = 0;
12629 double arg1 = (double) 0.0 ;
12630 double arg2 = (double) 0.0 ;
12631 double arg3 = (double) 0.0 ;
12632 wxImage_HSVValue *result = 0 ;
12633 double val1 ;
12634 int ecode1 = 0 ;
12635 double val2 ;
12636 int ecode2 = 0 ;
12637 double val3 ;
12638 int ecode3 = 0 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 char * kwnames[] = {
12643 (char *) "h",(char *) "s",(char *) "v", NULL
12644 };
12645
12646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12647 if (obj0) {
12648 ecode1 = SWIG_AsVal_double(obj0, &val1);
12649 if (!SWIG_IsOK(ecode1)) {
12650 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12651 }
12652 arg1 = static_cast< double >(val1);
12653 }
12654 if (obj1) {
12655 ecode2 = SWIG_AsVal_double(obj1, &val2);
12656 if (!SWIG_IsOK(ecode2)) {
12657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12658 }
12659 arg2 = static_cast< double >(val2);
12660 }
12661 if (obj2) {
12662 ecode3 = SWIG_AsVal_double(obj2, &val3);
12663 if (!SWIG_IsOK(ecode3)) {
12664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12665 }
12666 arg3 = static_cast< double >(val3);
12667 }
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12671 wxPyEndAllowThreads(__tstate);
12672 if (PyErr_Occurred()) SWIG_fail;
12673 }
12674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12675 return resultobj;
12676 fail:
12677 return NULL;
12678 }
12679
12680
12681 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12682 PyObject *resultobj = 0;
12683 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12684 double arg2 ;
12685 void *argp1 = 0 ;
12686 int res1 = 0 ;
12687 double val2 ;
12688 int ecode2 = 0 ;
12689 PyObject *swig_obj[2] ;
12690
12691 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12693 if (!SWIG_IsOK(res1)) {
12694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12695 }
12696 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12697 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12698 if (!SWIG_IsOK(ecode2)) {
12699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12700 }
12701 arg2 = static_cast< double >(val2);
12702 if (arg1) (arg1)->hue = arg2;
12703
12704 resultobj = SWIG_Py_Void();
12705 return resultobj;
12706 fail:
12707 return NULL;
12708 }
12709
12710
12711 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12712 PyObject *resultobj = 0;
12713 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12714 double result;
12715 void *argp1 = 0 ;
12716 int res1 = 0 ;
12717 PyObject *swig_obj[1] ;
12718
12719 if (!args) SWIG_fail;
12720 swig_obj[0] = args;
12721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12722 if (!SWIG_IsOK(res1)) {
12723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12724 }
12725 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12726 result = (double) ((arg1)->hue);
12727 resultobj = SWIG_From_double(static_cast< double >(result));
12728 return resultobj;
12729 fail:
12730 return NULL;
12731 }
12732
12733
12734 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12735 PyObject *resultobj = 0;
12736 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12737 double arg2 ;
12738 void *argp1 = 0 ;
12739 int res1 = 0 ;
12740 double val2 ;
12741 int ecode2 = 0 ;
12742 PyObject *swig_obj[2] ;
12743
12744 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12746 if (!SWIG_IsOK(res1)) {
12747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12748 }
12749 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12750 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12751 if (!SWIG_IsOK(ecode2)) {
12752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12753 }
12754 arg2 = static_cast< double >(val2);
12755 if (arg1) (arg1)->saturation = arg2;
12756
12757 resultobj = SWIG_Py_Void();
12758 return resultobj;
12759 fail:
12760 return NULL;
12761 }
12762
12763
12764 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12765 PyObject *resultobj = 0;
12766 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12767 double result;
12768 void *argp1 = 0 ;
12769 int res1 = 0 ;
12770 PyObject *swig_obj[1] ;
12771
12772 if (!args) SWIG_fail;
12773 swig_obj[0] = args;
12774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12777 }
12778 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12779 result = (double) ((arg1)->saturation);
12780 resultobj = SWIG_From_double(static_cast< double >(result));
12781 return resultobj;
12782 fail:
12783 return NULL;
12784 }
12785
12786
12787 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12788 PyObject *resultobj = 0;
12789 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12790 double arg2 ;
12791 void *argp1 = 0 ;
12792 int res1 = 0 ;
12793 double val2 ;
12794 int ecode2 = 0 ;
12795 PyObject *swig_obj[2] ;
12796
12797 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12799 if (!SWIG_IsOK(res1)) {
12800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12801 }
12802 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12803 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12804 if (!SWIG_IsOK(ecode2)) {
12805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12806 }
12807 arg2 = static_cast< double >(val2);
12808 if (arg1) (arg1)->value = arg2;
12809
12810 resultobj = SWIG_Py_Void();
12811 return resultobj;
12812 fail:
12813 return NULL;
12814 }
12815
12816
12817 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12818 PyObject *resultobj = 0;
12819 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12820 double result;
12821 void *argp1 = 0 ;
12822 int res1 = 0 ;
12823 PyObject *swig_obj[1] ;
12824
12825 if (!args) SWIG_fail;
12826 swig_obj[0] = args;
12827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12828 if (!SWIG_IsOK(res1)) {
12829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12830 }
12831 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12832 result = (double) ((arg1)->value);
12833 resultobj = SWIG_From_double(static_cast< double >(result));
12834 return resultobj;
12835 fail:
12836 return NULL;
12837 }
12838
12839
12840 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12841 PyObject *obj;
12842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12843 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12844 return SWIG_Py_Void();
12845 }
12846
12847 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12848 return SWIG_Python_InitShadowInstance(args);
12849 }
12850
12851 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj = 0;
12853 wxString *arg1 = 0 ;
12854 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12855 int arg3 = (int) -1 ;
12856 wxImage *result = 0 ;
12857 bool temp1 = false ;
12858 long val2 ;
12859 int ecode2 = 0 ;
12860 int val3 ;
12861 int ecode3 = 0 ;
12862 PyObject * obj0 = 0 ;
12863 PyObject * obj1 = 0 ;
12864 PyObject * obj2 = 0 ;
12865 char * kwnames[] = {
12866 (char *) "name",(char *) "type",(char *) "index", NULL
12867 };
12868
12869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12870 {
12871 arg1 = wxString_in_helper(obj0);
12872 if (arg1 == NULL) SWIG_fail;
12873 temp1 = true;
12874 }
12875 if (obj1) {
12876 ecode2 = SWIG_AsVal_long(obj1, &val2);
12877 if (!SWIG_IsOK(ecode2)) {
12878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12879 }
12880 arg2 = static_cast< long >(val2);
12881 }
12882 if (obj2) {
12883 ecode3 = SWIG_AsVal_int(obj2, &val3);
12884 if (!SWIG_IsOK(ecode3)) {
12885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12886 }
12887 arg3 = static_cast< int >(val3);
12888 }
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12896 {
12897 if (temp1)
12898 delete arg1;
12899 }
12900 return resultobj;
12901 fail:
12902 {
12903 if (temp1)
12904 delete arg1;
12905 }
12906 return NULL;
12907 }
12908
12909
12910 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12911 PyObject *resultobj = 0;
12912 wxImage *arg1 = (wxImage *) 0 ;
12913 void *argp1 = 0 ;
12914 int res1 = 0 ;
12915 PyObject *swig_obj[1] ;
12916
12917 if (!args) SWIG_fail;
12918 swig_obj[0] = args;
12919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12920 if (!SWIG_IsOK(res1)) {
12921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12922 }
12923 arg1 = reinterpret_cast< wxImage * >(argp1);
12924 {
12925 PyThreadState* __tstate = wxPyBeginAllowThreads();
12926 delete arg1;
12927
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 resultobj = SWIG_Py_Void();
12932 return resultobj;
12933 fail:
12934 return NULL;
12935 }
12936
12937
12938 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12939 PyObject *resultobj = 0;
12940 wxString *arg1 = 0 ;
12941 wxString *arg2 = 0 ;
12942 int arg3 = (int) -1 ;
12943 wxImage *result = 0 ;
12944 bool temp1 = false ;
12945 bool temp2 = false ;
12946 int val3 ;
12947 int ecode3 = 0 ;
12948 PyObject * obj0 = 0 ;
12949 PyObject * obj1 = 0 ;
12950 PyObject * obj2 = 0 ;
12951 char * kwnames[] = {
12952 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12953 };
12954
12955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12956 {
12957 arg1 = wxString_in_helper(obj0);
12958 if (arg1 == NULL) SWIG_fail;
12959 temp1 = true;
12960 }
12961 {
12962 arg2 = wxString_in_helper(obj1);
12963 if (arg2 == NULL) SWIG_fail;
12964 temp2 = true;
12965 }
12966 if (obj2) {
12967 ecode3 = SWIG_AsVal_int(obj2, &val3);
12968 if (!SWIG_IsOK(ecode3)) {
12969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12970 }
12971 arg3 = static_cast< int >(val3);
12972 }
12973 {
12974 PyThreadState* __tstate = wxPyBeginAllowThreads();
12975 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12976 wxPyEndAllowThreads(__tstate);
12977 if (PyErr_Occurred()) SWIG_fail;
12978 }
12979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12980 {
12981 if (temp1)
12982 delete arg1;
12983 }
12984 {
12985 if (temp2)
12986 delete arg2;
12987 }
12988 return resultobj;
12989 fail:
12990 {
12991 if (temp1)
12992 delete arg1;
12993 }
12994 {
12995 if (temp2)
12996 delete arg2;
12997 }
12998 return NULL;
12999 }
13000
13001
13002 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj = 0;
13004 wxInputStream *arg1 = 0 ;
13005 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13006 int arg3 = (int) -1 ;
13007 wxImage *result = 0 ;
13008 wxPyInputStream *temp1 ;
13009 bool created1 ;
13010 long val2 ;
13011 int ecode2 = 0 ;
13012 int val3 ;
13013 int ecode3 = 0 ;
13014 PyObject * obj0 = 0 ;
13015 PyObject * obj1 = 0 ;
13016 PyObject * obj2 = 0 ;
13017 char * kwnames[] = {
13018 (char *) "stream",(char *) "type",(char *) "index", NULL
13019 };
13020
13021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13022 {
13023 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13024 arg1 = temp1->m_wxis;
13025 created1 = false;
13026 } else {
13027 PyErr_Clear(); // clear the failure of the wxPyConvert above
13028 arg1 = wxPyCBInputStream_create(obj0, false);
13029 if (arg1 == NULL) {
13030 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13031 SWIG_fail;
13032 }
13033 created1 = true;
13034 }
13035 }
13036 if (obj1) {
13037 ecode2 = SWIG_AsVal_long(obj1, &val2);
13038 if (!SWIG_IsOK(ecode2)) {
13039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13040 }
13041 arg2 = static_cast< long >(val2);
13042 }
13043 if (obj2) {
13044 ecode3 = SWIG_AsVal_int(obj2, &val3);
13045 if (!SWIG_IsOK(ecode3)) {
13046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13047 }
13048 arg3 = static_cast< int >(val3);
13049 }
13050 {
13051 PyThreadState* __tstate = wxPyBeginAllowThreads();
13052 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13053 wxPyEndAllowThreads(__tstate);
13054 if (PyErr_Occurred()) SWIG_fail;
13055 }
13056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13057 {
13058 if (created1) delete arg1;
13059 }
13060 return resultobj;
13061 fail:
13062 {
13063 if (created1) delete arg1;
13064 }
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj = 0;
13071 wxInputStream *arg1 = 0 ;
13072 wxString *arg2 = 0 ;
13073 int arg3 = (int) -1 ;
13074 wxImage *result = 0 ;
13075 wxPyInputStream *temp1 ;
13076 bool created1 ;
13077 bool temp2 = false ;
13078 int val3 ;
13079 int ecode3 = 0 ;
13080 PyObject * obj0 = 0 ;
13081 PyObject * obj1 = 0 ;
13082 PyObject * obj2 = 0 ;
13083 char * kwnames[] = {
13084 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13085 };
13086
13087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13088 {
13089 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13090 arg1 = temp1->m_wxis;
13091 created1 = false;
13092 } else {
13093 PyErr_Clear(); // clear the failure of the wxPyConvert above
13094 arg1 = wxPyCBInputStream_create(obj0, false);
13095 if (arg1 == NULL) {
13096 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13097 SWIG_fail;
13098 }
13099 created1 = true;
13100 }
13101 }
13102 {
13103 arg2 = wxString_in_helper(obj1);
13104 if (arg2 == NULL) SWIG_fail;
13105 temp2 = true;
13106 }
13107 if (obj2) {
13108 ecode3 = SWIG_AsVal_int(obj2, &val3);
13109 if (!SWIG_IsOK(ecode3)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13111 }
13112 arg3 = static_cast< int >(val3);
13113 }
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13117 wxPyEndAllowThreads(__tstate);
13118 if (PyErr_Occurred()) SWIG_fail;
13119 }
13120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13121 {
13122 if (created1) delete arg1;
13123 }
13124 {
13125 if (temp2)
13126 delete arg2;
13127 }
13128 return resultobj;
13129 fail:
13130 {
13131 if (created1) delete arg1;
13132 }
13133 {
13134 if (temp2)
13135 delete arg2;
13136 }
13137 return NULL;
13138 }
13139
13140
13141 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13142 PyObject *resultobj = 0;
13143 int arg1 = (int) 0 ;
13144 int arg2 = (int) 0 ;
13145 bool arg3 = (bool) true ;
13146 wxImage *result = 0 ;
13147 int val1 ;
13148 int ecode1 = 0 ;
13149 int val2 ;
13150 int ecode2 = 0 ;
13151 bool val3 ;
13152 int ecode3 = 0 ;
13153 PyObject * obj0 = 0 ;
13154 PyObject * obj1 = 0 ;
13155 PyObject * obj2 = 0 ;
13156 char * kwnames[] = {
13157 (char *) "width",(char *) "height",(char *) "clear", NULL
13158 };
13159
13160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13161 if (obj0) {
13162 ecode1 = SWIG_AsVal_int(obj0, &val1);
13163 if (!SWIG_IsOK(ecode1)) {
13164 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13165 }
13166 arg1 = static_cast< int >(val1);
13167 }
13168 if (obj1) {
13169 ecode2 = SWIG_AsVal_int(obj1, &val2);
13170 if (!SWIG_IsOK(ecode2)) {
13171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13172 }
13173 arg2 = static_cast< int >(val2);
13174 }
13175 if (obj2) {
13176 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13177 if (!SWIG_IsOK(ecode3)) {
13178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13179 }
13180 arg3 = static_cast< bool >(val3);
13181 }
13182 {
13183 PyThreadState* __tstate = wxPyBeginAllowThreads();
13184 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj = 0;
13197 wxBitmap *arg1 = 0 ;
13198 wxImage *result = 0 ;
13199 void *argp1 = 0 ;
13200 int res1 = 0 ;
13201 PyObject * obj0 = 0 ;
13202 char * kwnames[] = {
13203 (char *) "bitmap", NULL
13204 };
13205
13206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13207 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13208 if (!SWIG_IsOK(res1)) {
13209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13210 }
13211 if (!argp1) {
13212 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13213 }
13214 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13215 {
13216 if (!wxPyCheckForApp()) SWIG_fail;
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj = 0;
13231 int arg1 ;
13232 int arg2 ;
13233 buffer arg3 ;
13234 int arg4 ;
13235 wxImage *result = 0 ;
13236 int val1 ;
13237 int ecode1 = 0 ;
13238 int val2 ;
13239 int ecode2 = 0 ;
13240 PyObject * obj0 = 0 ;
13241 PyObject * obj1 = 0 ;
13242 PyObject * obj2 = 0 ;
13243 char * kwnames[] = {
13244 (char *) "width",(char *) "height",(char *) "data", NULL
13245 };
13246
13247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13248 ecode1 = SWIG_AsVal_int(obj0, &val1);
13249 if (!SWIG_IsOK(ecode1)) {
13250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13251 }
13252 arg1 = static_cast< int >(val1);
13253 ecode2 = SWIG_AsVal_int(obj1, &val2);
13254 if (!SWIG_IsOK(ecode2)) {
13255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13256 }
13257 arg2 = static_cast< int >(val2);
13258 {
13259 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13260 }
13261 {
13262 PyThreadState* __tstate = wxPyBeginAllowThreads();
13263 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13268 return resultobj;
13269 fail:
13270 return NULL;
13271 }
13272
13273
13274 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13275 PyObject *resultobj = 0;
13276 int arg1 ;
13277 int arg2 ;
13278 buffer arg3 ;
13279 int arg4 ;
13280 buffer arg5 ;
13281 int arg6 ;
13282 wxImage *result = 0 ;
13283 int val1 ;
13284 int ecode1 = 0 ;
13285 int val2 ;
13286 int ecode2 = 0 ;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 PyObject * obj2 = 0 ;
13290 PyObject * obj3 = 0 ;
13291 char * kwnames[] = {
13292 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13293 };
13294
13295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13296 ecode1 = SWIG_AsVal_int(obj0, &val1);
13297 if (!SWIG_IsOK(ecode1)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13299 }
13300 arg1 = static_cast< int >(val1);
13301 ecode2 = SWIG_AsVal_int(obj1, &val2);
13302 if (!SWIG_IsOK(ecode2)) {
13303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13304 }
13305 arg2 = static_cast< int >(val2);
13306 {
13307 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13308 }
13309 {
13310 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13311 }
13312 {
13313 PyThreadState* __tstate = wxPyBeginAllowThreads();
13314 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13315 wxPyEndAllowThreads(__tstate);
13316 if (PyErr_Occurred()) SWIG_fail;
13317 }
13318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13319 return resultobj;
13320 fail:
13321 return NULL;
13322 }
13323
13324
13325 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13326 PyObject *resultobj = 0;
13327 wxImage *arg1 = (wxImage *) 0 ;
13328 int arg2 ;
13329 int arg3 ;
13330 bool arg4 = (bool) true ;
13331 void *argp1 = 0 ;
13332 int res1 = 0 ;
13333 int val2 ;
13334 int ecode2 = 0 ;
13335 int val3 ;
13336 int ecode3 = 0 ;
13337 bool val4 ;
13338 int ecode4 = 0 ;
13339 PyObject * obj0 = 0 ;
13340 PyObject * obj1 = 0 ;
13341 PyObject * obj2 = 0 ;
13342 PyObject * obj3 = 0 ;
13343 char * kwnames[] = {
13344 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13345 };
13346
13347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13349 if (!SWIG_IsOK(res1)) {
13350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13351 }
13352 arg1 = reinterpret_cast< wxImage * >(argp1);
13353 ecode2 = SWIG_AsVal_int(obj1, &val2);
13354 if (!SWIG_IsOK(ecode2)) {
13355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13356 }
13357 arg2 = static_cast< int >(val2);
13358 ecode3 = SWIG_AsVal_int(obj2, &val3);
13359 if (!SWIG_IsOK(ecode3)) {
13360 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13361 }
13362 arg3 = static_cast< int >(val3);
13363 if (obj3) {
13364 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13365 if (!SWIG_IsOK(ecode4)) {
13366 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13367 }
13368 arg4 = static_cast< bool >(val4);
13369 }
13370 {
13371 PyThreadState* __tstate = wxPyBeginAllowThreads();
13372 (arg1)->Create(arg2,arg3,arg4);
13373 wxPyEndAllowThreads(__tstate);
13374 if (PyErr_Occurred()) SWIG_fail;
13375 }
13376 resultobj = SWIG_Py_Void();
13377 return resultobj;
13378 fail:
13379 return NULL;
13380 }
13381
13382
13383 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13384 PyObject *resultobj = 0;
13385 wxImage *arg1 = (wxImage *) 0 ;
13386 void *argp1 = 0 ;
13387 int res1 = 0 ;
13388 PyObject *swig_obj[1] ;
13389
13390 if (!args) SWIG_fail;
13391 swig_obj[0] = args;
13392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13393 if (!SWIG_IsOK(res1)) {
13394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13395 }
13396 arg1 = reinterpret_cast< wxImage * >(argp1);
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 (arg1)->Destroy();
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_Py_Void();
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxImage *arg1 = (wxImage *) 0 ;
13413 int arg2 ;
13414 int arg3 ;
13415 SwigValueWrapper<wxImage > result;
13416 void *argp1 = 0 ;
13417 int res1 = 0 ;
13418 int val2 ;
13419 int ecode2 = 0 ;
13420 int val3 ;
13421 int ecode3 = 0 ;
13422 PyObject * obj0 = 0 ;
13423 PyObject * obj1 = 0 ;
13424 PyObject * obj2 = 0 ;
13425 char * kwnames[] = {
13426 (char *) "self",(char *) "width",(char *) "height", NULL
13427 };
13428
13429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13431 if (!SWIG_IsOK(res1)) {
13432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13433 }
13434 arg1 = reinterpret_cast< wxImage * >(argp1);
13435 ecode2 = SWIG_AsVal_int(obj1, &val2);
13436 if (!SWIG_IsOK(ecode2)) {
13437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13438 }
13439 arg2 = static_cast< int >(val2);
13440 ecode3 = SWIG_AsVal_int(obj2, &val3);
13441 if (!SWIG_IsOK(ecode3)) {
13442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13443 }
13444 arg3 = static_cast< int >(val3);
13445 {
13446 PyThreadState* __tstate = wxPyBeginAllowThreads();
13447 result = (arg1)->Scale(arg2,arg3);
13448 wxPyEndAllowThreads(__tstate);
13449 if (PyErr_Occurred()) SWIG_fail;
13450 }
13451 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13452 return resultobj;
13453 fail:
13454 return NULL;
13455 }
13456
13457
13458 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13459 PyObject *resultobj = 0;
13460 wxImage *arg1 = (wxImage *) 0 ;
13461 int arg2 ;
13462 int arg3 ;
13463 SwigValueWrapper<wxImage > result;
13464 void *argp1 = 0 ;
13465 int res1 = 0 ;
13466 int val2 ;
13467 int ecode2 = 0 ;
13468 int val3 ;
13469 int ecode3 = 0 ;
13470 PyObject * obj0 = 0 ;
13471 PyObject * obj1 = 0 ;
13472 PyObject * obj2 = 0 ;
13473 char * kwnames[] = {
13474 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13475 };
13476
13477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13479 if (!SWIG_IsOK(res1)) {
13480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13481 }
13482 arg1 = reinterpret_cast< wxImage * >(argp1);
13483 ecode2 = SWIG_AsVal_int(obj1, &val2);
13484 if (!SWIG_IsOK(ecode2)) {
13485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13486 }
13487 arg2 = static_cast< int >(val2);
13488 ecode3 = SWIG_AsVal_int(obj2, &val3);
13489 if (!SWIG_IsOK(ecode3)) {
13490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13491 }
13492 arg3 = static_cast< int >(val3);
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13496 wxPyEndAllowThreads(__tstate);
13497 if (PyErr_Occurred()) SWIG_fail;
13498 }
13499 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj = 0;
13508 wxImage *arg1 = (wxImage *) 0 ;
13509 int arg2 ;
13510 int arg3 ;
13511 wxImage *result = 0 ;
13512 void *argp1 = 0 ;
13513 int res1 = 0 ;
13514 int val2 ;
13515 int ecode2 = 0 ;
13516 int val3 ;
13517 int ecode3 = 0 ;
13518 PyObject * obj0 = 0 ;
13519 PyObject * obj1 = 0 ;
13520 PyObject * obj2 = 0 ;
13521 char * kwnames[] = {
13522 (char *) "self",(char *) "width",(char *) "height", NULL
13523 };
13524
13525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13527 if (!SWIG_IsOK(res1)) {
13528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13529 }
13530 arg1 = reinterpret_cast< wxImage * >(argp1);
13531 ecode2 = SWIG_AsVal_int(obj1, &val2);
13532 if (!SWIG_IsOK(ecode2)) {
13533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13534 }
13535 arg2 = static_cast< int >(val2);
13536 ecode3 = SWIG_AsVal_int(obj2, &val3);
13537 if (!SWIG_IsOK(ecode3)) {
13538 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13539 }
13540 arg3 = static_cast< int >(val3);
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 {
13544 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13545 result = (wxImage *) &_result_ref;
13546 }
13547 wxPyEndAllowThreads(__tstate);
13548 if (PyErr_Occurred()) SWIG_fail;
13549 }
13550 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13551 return resultobj;
13552 fail:
13553 return NULL;
13554 }
13555
13556
13557 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13558 PyObject *resultobj = 0;
13559 wxImage *arg1 = (wxImage *) 0 ;
13560 wxSize *arg2 = 0 ;
13561 wxPoint *arg3 = 0 ;
13562 int arg4 = (int) -1 ;
13563 int arg5 = (int) -1 ;
13564 int arg6 = (int) -1 ;
13565 wxImage *result = 0 ;
13566 void *argp1 = 0 ;
13567 int res1 = 0 ;
13568 wxSize temp2 ;
13569 wxPoint temp3 ;
13570 int val4 ;
13571 int ecode4 = 0 ;
13572 int val5 ;
13573 int ecode5 = 0 ;
13574 int val6 ;
13575 int ecode6 = 0 ;
13576 PyObject * obj0 = 0 ;
13577 PyObject * obj1 = 0 ;
13578 PyObject * obj2 = 0 ;
13579 PyObject * obj3 = 0 ;
13580 PyObject * obj4 = 0 ;
13581 PyObject * obj5 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13590 }
13591 arg1 = reinterpret_cast< wxImage * >(argp1);
13592 {
13593 arg2 = &temp2;
13594 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13595 }
13596 {
13597 arg3 = &temp3;
13598 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13599 }
13600 if (obj3) {
13601 ecode4 = SWIG_AsVal_int(obj3, &val4);
13602 if (!SWIG_IsOK(ecode4)) {
13603 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13604 }
13605 arg4 = static_cast< int >(val4);
13606 }
13607 if (obj4) {
13608 ecode5 = SWIG_AsVal_int(obj4, &val5);
13609 if (!SWIG_IsOK(ecode5)) {
13610 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13611 }
13612 arg5 = static_cast< int >(val5);
13613 }
13614 if (obj5) {
13615 ecode6 = SWIG_AsVal_int(obj5, &val6);
13616 if (!SWIG_IsOK(ecode6)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13618 }
13619 arg6 = static_cast< int >(val6);
13620 }
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 {
13624 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13625 result = (wxImage *) &_result_ref;
13626 }
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13638 PyObject *resultobj = 0;
13639 wxImage *arg1 = (wxImage *) 0 ;
13640 int arg2 ;
13641 int arg3 ;
13642 byte arg4 ;
13643 byte arg5 ;
13644 byte arg6 ;
13645 void *argp1 = 0 ;
13646 int res1 = 0 ;
13647 int val2 ;
13648 int ecode2 = 0 ;
13649 int val3 ;
13650 int ecode3 = 0 ;
13651 unsigned char val4 ;
13652 int ecode4 = 0 ;
13653 unsigned char val5 ;
13654 int ecode5 = 0 ;
13655 unsigned char val6 ;
13656 int ecode6 = 0 ;
13657 PyObject * obj0 = 0 ;
13658 PyObject * obj1 = 0 ;
13659 PyObject * obj2 = 0 ;
13660 PyObject * obj3 = 0 ;
13661 PyObject * obj4 = 0 ;
13662 PyObject * obj5 = 0 ;
13663 char * kwnames[] = {
13664 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13665 };
13666
13667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13671 }
13672 arg1 = reinterpret_cast< wxImage * >(argp1);
13673 ecode2 = SWIG_AsVal_int(obj1, &val2);
13674 if (!SWIG_IsOK(ecode2)) {
13675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13676 }
13677 arg2 = static_cast< int >(val2);
13678 ecode3 = SWIG_AsVal_int(obj2, &val3);
13679 if (!SWIG_IsOK(ecode3)) {
13680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13681 }
13682 arg3 = static_cast< int >(val3);
13683 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13684 if (!SWIG_IsOK(ecode4)) {
13685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13686 }
13687 arg4 = static_cast< byte >(val4);
13688 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13689 if (!SWIG_IsOK(ecode5)) {
13690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13691 }
13692 arg5 = static_cast< byte >(val5);
13693 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13694 if (!SWIG_IsOK(ecode6)) {
13695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13696 }
13697 arg6 = static_cast< byte >(val6);
13698 {
13699 PyThreadState* __tstate = wxPyBeginAllowThreads();
13700 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 resultobj = SWIG_Py_Void();
13705 return resultobj;
13706 fail:
13707 return NULL;
13708 }
13709
13710
13711 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj = 0;
13713 wxImage *arg1 = (wxImage *) 0 ;
13714 wxRect *arg2 = 0 ;
13715 byte arg3 ;
13716 byte arg4 ;
13717 byte arg5 ;
13718 void *argp1 = 0 ;
13719 int res1 = 0 ;
13720 wxRect temp2 ;
13721 unsigned char val3 ;
13722 int ecode3 = 0 ;
13723 unsigned char val4 ;
13724 int ecode4 = 0 ;
13725 unsigned char val5 ;
13726 int ecode5 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 PyObject * obj2 = 0 ;
13730 PyObject * obj3 = 0 ;
13731 PyObject * obj4 = 0 ;
13732 char * kwnames[] = {
13733 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13734 };
13735
13736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13738 if (!SWIG_IsOK(res1)) {
13739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13740 }
13741 arg1 = reinterpret_cast< wxImage * >(argp1);
13742 {
13743 arg2 = &temp2;
13744 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13745 }
13746 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13747 if (!SWIG_IsOK(ecode3)) {
13748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13749 }
13750 arg3 = static_cast< byte >(val3);
13751 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13752 if (!SWIG_IsOK(ecode4)) {
13753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13754 }
13755 arg4 = static_cast< byte >(val4);
13756 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13757 if (!SWIG_IsOK(ecode5)) {
13758 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13759 }
13760 arg5 = static_cast< byte >(val5);
13761 {
13762 PyThreadState* __tstate = wxPyBeginAllowThreads();
13763 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13764 wxPyEndAllowThreads(__tstate);
13765 if (PyErr_Occurred()) SWIG_fail;
13766 }
13767 resultobj = SWIG_Py_Void();
13768 return resultobj;
13769 fail:
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13775 PyObject *resultobj = 0;
13776 wxImage *arg1 = (wxImage *) 0 ;
13777 int arg2 ;
13778 int arg3 ;
13779 byte result;
13780 void *argp1 = 0 ;
13781 int res1 = 0 ;
13782 int val2 ;
13783 int ecode2 = 0 ;
13784 int val3 ;
13785 int ecode3 = 0 ;
13786 PyObject * obj0 = 0 ;
13787 PyObject * obj1 = 0 ;
13788 PyObject * obj2 = 0 ;
13789 char * kwnames[] = {
13790 (char *) "self",(char *) "x",(char *) "y", NULL
13791 };
13792
13793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13795 if (!SWIG_IsOK(res1)) {
13796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13797 }
13798 arg1 = reinterpret_cast< wxImage * >(argp1);
13799 ecode2 = SWIG_AsVal_int(obj1, &val2);
13800 if (!SWIG_IsOK(ecode2)) {
13801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13802 }
13803 arg2 = static_cast< int >(val2);
13804 ecode3 = SWIG_AsVal_int(obj2, &val3);
13805 if (!SWIG_IsOK(ecode3)) {
13806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13807 }
13808 arg3 = static_cast< int >(val3);
13809 {
13810 PyThreadState* __tstate = wxPyBeginAllowThreads();
13811 result = (byte)(arg1)->GetRed(arg2,arg3);
13812 wxPyEndAllowThreads(__tstate);
13813 if (PyErr_Occurred()) SWIG_fail;
13814 }
13815 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13816 return resultobj;
13817 fail:
13818 return NULL;
13819 }
13820
13821
13822 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13823 PyObject *resultobj = 0;
13824 wxImage *arg1 = (wxImage *) 0 ;
13825 int arg2 ;
13826 int arg3 ;
13827 byte result;
13828 void *argp1 = 0 ;
13829 int res1 = 0 ;
13830 int val2 ;
13831 int ecode2 = 0 ;
13832 int val3 ;
13833 int ecode3 = 0 ;
13834 PyObject * obj0 = 0 ;
13835 PyObject * obj1 = 0 ;
13836 PyObject * obj2 = 0 ;
13837 char * kwnames[] = {
13838 (char *) "self",(char *) "x",(char *) "y", NULL
13839 };
13840
13841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13843 if (!SWIG_IsOK(res1)) {
13844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13845 }
13846 arg1 = reinterpret_cast< wxImage * >(argp1);
13847 ecode2 = SWIG_AsVal_int(obj1, &val2);
13848 if (!SWIG_IsOK(ecode2)) {
13849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13850 }
13851 arg2 = static_cast< int >(val2);
13852 ecode3 = SWIG_AsVal_int(obj2, &val3);
13853 if (!SWIG_IsOK(ecode3)) {
13854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13855 }
13856 arg3 = static_cast< int >(val3);
13857 {
13858 PyThreadState* __tstate = wxPyBeginAllowThreads();
13859 result = (byte)(arg1)->GetGreen(arg2,arg3);
13860 wxPyEndAllowThreads(__tstate);
13861 if (PyErr_Occurred()) SWIG_fail;
13862 }
13863 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13864 return resultobj;
13865 fail:
13866 return NULL;
13867 }
13868
13869
13870 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj = 0;
13872 wxImage *arg1 = (wxImage *) 0 ;
13873 int arg2 ;
13874 int arg3 ;
13875 byte result;
13876 void *argp1 = 0 ;
13877 int res1 = 0 ;
13878 int val2 ;
13879 int ecode2 = 0 ;
13880 int val3 ;
13881 int ecode3 = 0 ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 PyObject * obj2 = 0 ;
13885 char * kwnames[] = {
13886 (char *) "self",(char *) "x",(char *) "y", NULL
13887 };
13888
13889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13891 if (!SWIG_IsOK(res1)) {
13892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13893 }
13894 arg1 = reinterpret_cast< wxImage * >(argp1);
13895 ecode2 = SWIG_AsVal_int(obj1, &val2);
13896 if (!SWIG_IsOK(ecode2)) {
13897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13898 }
13899 arg2 = static_cast< int >(val2);
13900 ecode3 = SWIG_AsVal_int(obj2, &val3);
13901 if (!SWIG_IsOK(ecode3)) {
13902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13903 }
13904 arg3 = static_cast< int >(val3);
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 result = (byte)(arg1)->GetBlue(arg2,arg3);
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13912 return resultobj;
13913 fail:
13914 return NULL;
13915 }
13916
13917
13918 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj = 0;
13920 wxImage *arg1 = (wxImage *) 0 ;
13921 int arg2 ;
13922 int arg3 ;
13923 byte arg4 ;
13924 void *argp1 = 0 ;
13925 int res1 = 0 ;
13926 int val2 ;
13927 int ecode2 = 0 ;
13928 int val3 ;
13929 int ecode3 = 0 ;
13930 unsigned char val4 ;
13931 int ecode4 = 0 ;
13932 PyObject * obj0 = 0 ;
13933 PyObject * obj1 = 0 ;
13934 PyObject * obj2 = 0 ;
13935 PyObject * obj3 = 0 ;
13936 char * kwnames[] = {
13937 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13938 };
13939
13940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13942 if (!SWIG_IsOK(res1)) {
13943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13944 }
13945 arg1 = reinterpret_cast< wxImage * >(argp1);
13946 ecode2 = SWIG_AsVal_int(obj1, &val2);
13947 if (!SWIG_IsOK(ecode2)) {
13948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13949 }
13950 arg2 = static_cast< int >(val2);
13951 ecode3 = SWIG_AsVal_int(obj2, &val3);
13952 if (!SWIG_IsOK(ecode3)) {
13953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13954 }
13955 arg3 = static_cast< int >(val3);
13956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13957 if (!SWIG_IsOK(ecode4)) {
13958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13959 }
13960 arg4 = static_cast< byte >(val4);
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 (arg1)->SetAlpha(arg2,arg3,arg4);
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 resultobj = SWIG_Py_Void();
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj = 0;
13976 wxImage *arg1 = (wxImage *) 0 ;
13977 int arg2 ;
13978 int arg3 ;
13979 byte result;
13980 void *argp1 = 0 ;
13981 int res1 = 0 ;
13982 int val2 ;
13983 int ecode2 = 0 ;
13984 int val3 ;
13985 int ecode3 = 0 ;
13986 PyObject * obj0 = 0 ;
13987 PyObject * obj1 = 0 ;
13988 PyObject * obj2 = 0 ;
13989 char * kwnames[] = {
13990 (char *) "self",(char *) "x",(char *) "y", NULL
13991 };
13992
13993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13995 if (!SWIG_IsOK(res1)) {
13996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13997 }
13998 arg1 = reinterpret_cast< wxImage * >(argp1);
13999 ecode2 = SWIG_AsVal_int(obj1, &val2);
14000 if (!SWIG_IsOK(ecode2)) {
14001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14002 }
14003 arg2 = static_cast< int >(val2);
14004 ecode3 = SWIG_AsVal_int(obj2, &val3);
14005 if (!SWIG_IsOK(ecode3)) {
14006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14007 }
14008 arg3 = static_cast< int >(val3);
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14012 wxPyEndAllowThreads(__tstate);
14013 if (PyErr_Occurred()) SWIG_fail;
14014 }
14015 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14016 return resultobj;
14017 fail:
14018 return NULL;
14019 }
14020
14021
14022 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14023 PyObject *resultobj = 0;
14024 wxImage *arg1 = (wxImage *) 0 ;
14025 bool result;
14026 void *argp1 = 0 ;
14027 int res1 = 0 ;
14028 PyObject *swig_obj[1] ;
14029
14030 if (!args) SWIG_fail;
14031 swig_obj[0] = args;
14032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14033 if (!SWIG_IsOK(res1)) {
14034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14035 }
14036 arg1 = reinterpret_cast< wxImage * >(argp1);
14037 {
14038 PyThreadState* __tstate = wxPyBeginAllowThreads();
14039 result = (bool)(arg1)->HasAlpha();
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 {
14044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14045 }
14046 return resultobj;
14047 fail:
14048 return NULL;
14049 }
14050
14051
14052 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14053 PyObject *resultobj = 0;
14054 wxImage *arg1 = (wxImage *) 0 ;
14055 void *argp1 = 0 ;
14056 int res1 = 0 ;
14057 PyObject *swig_obj[1] ;
14058
14059 if (!args) SWIG_fail;
14060 swig_obj[0] = args;
14061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14062 if (!SWIG_IsOK(res1)) {
14063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14064 }
14065 arg1 = reinterpret_cast< wxImage * >(argp1);
14066 {
14067 PyThreadState* __tstate = wxPyBeginAllowThreads();
14068 (arg1)->InitAlpha();
14069 wxPyEndAllowThreads(__tstate);
14070 if (PyErr_Occurred()) SWIG_fail;
14071 }
14072 resultobj = SWIG_Py_Void();
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj = 0;
14081 wxImage *arg1 = (wxImage *) 0 ;
14082 int arg2 ;
14083 int arg3 ;
14084 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14085 bool result;
14086 void *argp1 = 0 ;
14087 int res1 = 0 ;
14088 int val2 ;
14089 int ecode2 = 0 ;
14090 int val3 ;
14091 int ecode3 = 0 ;
14092 unsigned char val4 ;
14093 int ecode4 = 0 ;
14094 PyObject * obj0 = 0 ;
14095 PyObject * obj1 = 0 ;
14096 PyObject * obj2 = 0 ;
14097 PyObject * obj3 = 0 ;
14098 char * kwnames[] = {
14099 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14100 };
14101
14102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14104 if (!SWIG_IsOK(res1)) {
14105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14106 }
14107 arg1 = reinterpret_cast< wxImage * >(argp1);
14108 ecode2 = SWIG_AsVal_int(obj1, &val2);
14109 if (!SWIG_IsOK(ecode2)) {
14110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14111 }
14112 arg2 = static_cast< int >(val2);
14113 ecode3 = SWIG_AsVal_int(obj2, &val3);
14114 if (!SWIG_IsOK(ecode3)) {
14115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14116 }
14117 arg3 = static_cast< int >(val3);
14118 if (obj3) {
14119 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14120 if (!SWIG_IsOK(ecode4)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14122 }
14123 arg4 = static_cast< byte >(val4);
14124 }
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14128 wxPyEndAllowThreads(__tstate);
14129 if (PyErr_Occurred()) SWIG_fail;
14130 }
14131 {
14132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14133 }
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj = 0;
14142 wxImage *arg1 = (wxImage *) 0 ;
14143 byte *arg2 = (byte *) 0 ;
14144 byte *arg3 = (byte *) 0 ;
14145 byte *arg4 = (byte *) 0 ;
14146 byte arg5 = (byte) 0 ;
14147 byte arg6 = (byte) 0 ;
14148 byte arg7 = (byte) 0 ;
14149 bool result;
14150 void *argp1 = 0 ;
14151 int res1 = 0 ;
14152 byte temp2 ;
14153 int res2 = SWIG_TMPOBJ ;
14154 byte temp3 ;
14155 int res3 = SWIG_TMPOBJ ;
14156 byte temp4 ;
14157 int res4 = SWIG_TMPOBJ ;
14158 unsigned char val5 ;
14159 int ecode5 = 0 ;
14160 unsigned char val6 ;
14161 int ecode6 = 0 ;
14162 unsigned char val7 ;
14163 int ecode7 = 0 ;
14164 PyObject * obj0 = 0 ;
14165 PyObject * obj1 = 0 ;
14166 PyObject * obj2 = 0 ;
14167 PyObject * obj3 = 0 ;
14168 char * kwnames[] = {
14169 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14170 };
14171
14172 arg2 = &temp2;
14173 arg3 = &temp3;
14174 arg4 = &temp4;
14175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14179 }
14180 arg1 = reinterpret_cast< wxImage * >(argp1);
14181 if (obj1) {
14182 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14183 if (!SWIG_IsOK(ecode5)) {
14184 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14185 }
14186 arg5 = static_cast< byte >(val5);
14187 }
14188 if (obj2) {
14189 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14190 if (!SWIG_IsOK(ecode6)) {
14191 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14192 }
14193 arg6 = static_cast< byte >(val6);
14194 }
14195 if (obj3) {
14196 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14197 if (!SWIG_IsOK(ecode7)) {
14198 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14199 }
14200 arg7 = static_cast< byte >(val7);
14201 }
14202 {
14203 PyThreadState* __tstate = wxPyBeginAllowThreads();
14204 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14205 wxPyEndAllowThreads(__tstate);
14206 if (PyErr_Occurred()) SWIG_fail;
14207 }
14208 {
14209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14210 }
14211 if (SWIG_IsTmpObj(res2)) {
14212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14213 } else {
14214 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14216 }
14217 if (SWIG_IsTmpObj(res3)) {
14218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14219 } else {
14220 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14222 }
14223 if (SWIG_IsTmpObj(res4)) {
14224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14225 } else {
14226 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14228 }
14229 return resultobj;
14230 fail:
14231 return NULL;
14232 }
14233
14234
14235 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14236 PyObject *resultobj = 0;
14237 wxImage *arg1 = (wxImage *) 0 ;
14238 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14239 bool result;
14240 void *argp1 = 0 ;
14241 int res1 = 0 ;
14242 unsigned char val2 ;
14243 int ecode2 = 0 ;
14244 PyObject * obj0 = 0 ;
14245 PyObject * obj1 = 0 ;
14246 char * kwnames[] = {
14247 (char *) "self",(char *) "threshold", NULL
14248 };
14249
14250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14252 if (!SWIG_IsOK(res1)) {
14253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14254 }
14255 arg1 = reinterpret_cast< wxImage * >(argp1);
14256 if (obj1) {
14257 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14258 if (!SWIG_IsOK(ecode2)) {
14259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14260 }
14261 arg2 = static_cast< byte >(val2);
14262 }
14263 {
14264 PyThreadState* __tstate = wxPyBeginAllowThreads();
14265 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14266 wxPyEndAllowThreads(__tstate);
14267 if (PyErr_Occurred()) SWIG_fail;
14268 }
14269 {
14270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14271 }
14272 return resultobj;
14273 fail:
14274 return NULL;
14275 }
14276
14277
14278 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14279 PyObject *resultobj = 0;
14280 wxImage *arg1 = (wxImage *) 0 ;
14281 byte arg2 ;
14282 byte arg3 ;
14283 byte arg4 ;
14284 bool result;
14285 void *argp1 = 0 ;
14286 int res1 = 0 ;
14287 unsigned char val2 ;
14288 int ecode2 = 0 ;
14289 unsigned char val3 ;
14290 int ecode3 = 0 ;
14291 unsigned char val4 ;
14292 int ecode4 = 0 ;
14293 PyObject * obj0 = 0 ;
14294 PyObject * obj1 = 0 ;
14295 PyObject * obj2 = 0 ;
14296 PyObject * obj3 = 0 ;
14297 char * kwnames[] = {
14298 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14299 };
14300
14301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14303 if (!SWIG_IsOK(res1)) {
14304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14305 }
14306 arg1 = reinterpret_cast< wxImage * >(argp1);
14307 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14308 if (!SWIG_IsOK(ecode2)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14310 }
14311 arg2 = static_cast< byte >(val2);
14312 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14313 if (!SWIG_IsOK(ecode3)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14315 }
14316 arg3 = static_cast< byte >(val3);
14317 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14318 if (!SWIG_IsOK(ecode4)) {
14319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14320 }
14321 arg4 = static_cast< byte >(val4);
14322 {
14323 PyThreadState* __tstate = wxPyBeginAllowThreads();
14324 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 {
14329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14330 }
14331 return resultobj;
14332 fail:
14333 return NULL;
14334 }
14335
14336
14337 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14338 PyObject *resultobj = 0;
14339 wxImage *arg1 = (wxImage *) 0 ;
14340 wxImage *arg2 = 0 ;
14341 byte arg3 ;
14342 byte arg4 ;
14343 byte arg5 ;
14344 bool result;
14345 void *argp1 = 0 ;
14346 int res1 = 0 ;
14347 void *argp2 = 0 ;
14348 int res2 = 0 ;
14349 unsigned char val3 ;
14350 int ecode3 = 0 ;
14351 unsigned char val4 ;
14352 int ecode4 = 0 ;
14353 unsigned char val5 ;
14354 int ecode5 = 0 ;
14355 PyObject * obj0 = 0 ;
14356 PyObject * obj1 = 0 ;
14357 PyObject * obj2 = 0 ;
14358 PyObject * obj3 = 0 ;
14359 PyObject * obj4 = 0 ;
14360 char * kwnames[] = {
14361 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14362 };
14363
14364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14366 if (!SWIG_IsOK(res1)) {
14367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14368 }
14369 arg1 = reinterpret_cast< wxImage * >(argp1);
14370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14371 if (!SWIG_IsOK(res2)) {
14372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14373 }
14374 if (!argp2) {
14375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14376 }
14377 arg2 = reinterpret_cast< wxImage * >(argp2);
14378 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14379 if (!SWIG_IsOK(ecode3)) {
14380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14381 }
14382 arg3 = static_cast< byte >(val3);
14383 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14384 if (!SWIG_IsOK(ecode4)) {
14385 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14386 }
14387 arg4 = static_cast< byte >(val4);
14388 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14389 if (!SWIG_IsOK(ecode5)) {
14390 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14391 }
14392 arg5 = static_cast< byte >(val5);
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 {
14400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14401 }
14402 return resultobj;
14403 fail:
14404 return NULL;
14405 }
14406
14407
14408 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14409 PyObject *resultobj = 0;
14410 wxString *arg1 = 0 ;
14411 bool result;
14412 bool temp1 = false ;
14413 PyObject * obj0 = 0 ;
14414 char * kwnames[] = {
14415 (char *) "filename", NULL
14416 };
14417
14418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14419 {
14420 arg1 = wxString_in_helper(obj0);
14421 if (arg1 == NULL) SWIG_fail;
14422 temp1 = true;
14423 }
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 {
14431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14432 }
14433 {
14434 if (temp1)
14435 delete arg1;
14436 }
14437 return resultobj;
14438 fail:
14439 {
14440 if (temp1)
14441 delete arg1;
14442 }
14443 return NULL;
14444 }
14445
14446
14447 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14448 PyObject *resultobj = 0;
14449 wxString *arg1 = 0 ;
14450 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14451 int result;
14452 bool temp1 = false ;
14453 long val2 ;
14454 int ecode2 = 0 ;
14455 PyObject * obj0 = 0 ;
14456 PyObject * obj1 = 0 ;
14457 char * kwnames[] = {
14458 (char *) "filename",(char *) "type", NULL
14459 };
14460
14461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14462 {
14463 arg1 = wxString_in_helper(obj0);
14464 if (arg1 == NULL) SWIG_fail;
14465 temp1 = true;
14466 }
14467 if (obj1) {
14468 ecode2 = SWIG_AsVal_long(obj1, &val2);
14469 if (!SWIG_IsOK(ecode2)) {
14470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14471 }
14472 arg2 = static_cast< long >(val2);
14473 }
14474 {
14475 PyThreadState* __tstate = wxPyBeginAllowThreads();
14476 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 resultobj = SWIG_From_int(static_cast< int >(result));
14481 {
14482 if (temp1)
14483 delete arg1;
14484 }
14485 return resultobj;
14486 fail:
14487 {
14488 if (temp1)
14489 delete arg1;
14490 }
14491 return NULL;
14492 }
14493
14494
14495 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14496 PyObject *resultobj = 0;
14497 wxImage *arg1 = (wxImage *) 0 ;
14498 wxString *arg2 = 0 ;
14499 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14500 int arg4 = (int) -1 ;
14501 bool result;
14502 void *argp1 = 0 ;
14503 int res1 = 0 ;
14504 bool temp2 = false ;
14505 long val3 ;
14506 int ecode3 = 0 ;
14507 int val4 ;
14508 int ecode4 = 0 ;
14509 PyObject * obj0 = 0 ;
14510 PyObject * obj1 = 0 ;
14511 PyObject * obj2 = 0 ;
14512 PyObject * obj3 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14519 if (!SWIG_IsOK(res1)) {
14520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14521 }
14522 arg1 = reinterpret_cast< wxImage * >(argp1);
14523 {
14524 arg2 = wxString_in_helper(obj1);
14525 if (arg2 == NULL) SWIG_fail;
14526 temp2 = true;
14527 }
14528 if (obj2) {
14529 ecode3 = SWIG_AsVal_long(obj2, &val3);
14530 if (!SWIG_IsOK(ecode3)) {
14531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14532 }
14533 arg3 = static_cast< long >(val3);
14534 }
14535 if (obj3) {
14536 ecode4 = SWIG_AsVal_int(obj3, &val4);
14537 if (!SWIG_IsOK(ecode4)) {
14538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14539 }
14540 arg4 = static_cast< int >(val4);
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 {
14549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14550 }
14551 {
14552 if (temp2)
14553 delete arg2;
14554 }
14555 return resultobj;
14556 fail:
14557 {
14558 if (temp2)
14559 delete arg2;
14560 }
14561 return NULL;
14562 }
14563
14564
14565 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14566 PyObject *resultobj = 0;
14567 wxImage *arg1 = (wxImage *) 0 ;
14568 wxString *arg2 = 0 ;
14569 wxString *arg3 = 0 ;
14570 int arg4 = (int) -1 ;
14571 bool result;
14572 void *argp1 = 0 ;
14573 int res1 = 0 ;
14574 bool temp2 = false ;
14575 bool temp3 = false ;
14576 int val4 ;
14577 int ecode4 = 0 ;
14578 PyObject * obj0 = 0 ;
14579 PyObject * obj1 = 0 ;
14580 PyObject * obj2 = 0 ;
14581 PyObject * obj3 = 0 ;
14582 char * kwnames[] = {
14583 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14584 };
14585
14586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14588 if (!SWIG_IsOK(res1)) {
14589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14590 }
14591 arg1 = reinterpret_cast< wxImage * >(argp1);
14592 {
14593 arg2 = wxString_in_helper(obj1);
14594 if (arg2 == NULL) SWIG_fail;
14595 temp2 = true;
14596 }
14597 {
14598 arg3 = wxString_in_helper(obj2);
14599 if (arg3 == NULL) SWIG_fail;
14600 temp3 = true;
14601 }
14602 if (obj3) {
14603 ecode4 = SWIG_AsVal_int(obj3, &val4);
14604 if (!SWIG_IsOK(ecode4)) {
14605 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14606 }
14607 arg4 = static_cast< int >(val4);
14608 }
14609 {
14610 PyThreadState* __tstate = wxPyBeginAllowThreads();
14611 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14612 wxPyEndAllowThreads(__tstate);
14613 if (PyErr_Occurred()) SWIG_fail;
14614 }
14615 {
14616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14617 }
14618 {
14619 if (temp2)
14620 delete arg2;
14621 }
14622 {
14623 if (temp3)
14624 delete arg3;
14625 }
14626 return resultobj;
14627 fail:
14628 {
14629 if (temp2)
14630 delete arg2;
14631 }
14632 {
14633 if (temp3)
14634 delete arg3;
14635 }
14636 return NULL;
14637 }
14638
14639
14640 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14641 PyObject *resultobj = 0;
14642 wxImage *arg1 = (wxImage *) 0 ;
14643 wxString *arg2 = 0 ;
14644 int arg3 ;
14645 bool result;
14646 void *argp1 = 0 ;
14647 int res1 = 0 ;
14648 bool temp2 = false ;
14649 int val3 ;
14650 int ecode3 = 0 ;
14651 PyObject * obj0 = 0 ;
14652 PyObject * obj1 = 0 ;
14653 PyObject * obj2 = 0 ;
14654 char * kwnames[] = {
14655 (char *) "self",(char *) "name",(char *) "type", NULL
14656 };
14657
14658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14660 if (!SWIG_IsOK(res1)) {
14661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14662 }
14663 arg1 = reinterpret_cast< wxImage * >(argp1);
14664 {
14665 arg2 = wxString_in_helper(obj1);
14666 if (arg2 == NULL) SWIG_fail;
14667 temp2 = true;
14668 }
14669 ecode3 = SWIG_AsVal_int(obj2, &val3);
14670 if (!SWIG_IsOK(ecode3)) {
14671 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14672 }
14673 arg3 = static_cast< int >(val3);
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 {
14681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14682 }
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 return resultobj;
14688 fail:
14689 {
14690 if (temp2)
14691 delete arg2;
14692 }
14693 return NULL;
14694 }
14695
14696
14697 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14698 PyObject *resultobj = 0;
14699 wxImage *arg1 = (wxImage *) 0 ;
14700 wxString *arg2 = 0 ;
14701 wxString *arg3 = 0 ;
14702 bool result;
14703 void *argp1 = 0 ;
14704 int res1 = 0 ;
14705 bool temp2 = false ;
14706 bool temp3 = false ;
14707 PyObject * obj0 = 0 ;
14708 PyObject * obj1 = 0 ;
14709 PyObject * obj2 = 0 ;
14710 char * kwnames[] = {
14711 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14712 };
14713
14714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14716 if (!SWIG_IsOK(res1)) {
14717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14718 }
14719 arg1 = reinterpret_cast< wxImage * >(argp1);
14720 {
14721 arg2 = wxString_in_helper(obj1);
14722 if (arg2 == NULL) SWIG_fail;
14723 temp2 = true;
14724 }
14725 {
14726 arg3 = wxString_in_helper(obj2);
14727 if (arg3 == NULL) SWIG_fail;
14728 temp3 = true;
14729 }
14730 {
14731 PyThreadState* __tstate = wxPyBeginAllowThreads();
14732 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14733 wxPyEndAllowThreads(__tstate);
14734 if (PyErr_Occurred()) SWIG_fail;
14735 }
14736 {
14737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14738 }
14739 {
14740 if (temp2)
14741 delete arg2;
14742 }
14743 {
14744 if (temp3)
14745 delete arg3;
14746 }
14747 return resultobj;
14748 fail:
14749 {
14750 if (temp2)
14751 delete arg2;
14752 }
14753 {
14754 if (temp3)
14755 delete arg3;
14756 }
14757 return NULL;
14758 }
14759
14760
14761 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14762 PyObject *resultobj = 0;
14763 wxInputStream *arg1 = 0 ;
14764 bool result;
14765 wxPyInputStream *temp1 ;
14766 bool created1 ;
14767 PyObject * obj0 = 0 ;
14768 char * kwnames[] = {
14769 (char *) "stream", NULL
14770 };
14771
14772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14773 {
14774 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14775 arg1 = temp1->m_wxis;
14776 created1 = false;
14777 } else {
14778 PyErr_Clear(); // clear the failure of the wxPyConvert above
14779 arg1 = wxPyCBInputStream_create(obj0, false);
14780 if (arg1 == NULL) {
14781 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14782 SWIG_fail;
14783 }
14784 created1 = true;
14785 }
14786 }
14787 {
14788 PyThreadState* __tstate = wxPyBeginAllowThreads();
14789 result = (bool)wxImage::CanRead(*arg1);
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 {
14794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14795 }
14796 {
14797 if (created1) delete arg1;
14798 }
14799 return resultobj;
14800 fail:
14801 {
14802 if (created1) delete arg1;
14803 }
14804 return NULL;
14805 }
14806
14807
14808 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14809 PyObject *resultobj = 0;
14810 wxImage *arg1 = (wxImage *) 0 ;
14811 wxInputStream *arg2 = 0 ;
14812 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14813 int arg4 = (int) -1 ;
14814 bool result;
14815 void *argp1 = 0 ;
14816 int res1 = 0 ;
14817 wxPyInputStream *temp2 ;
14818 bool created2 ;
14819 long val3 ;
14820 int ecode3 = 0 ;
14821 int val4 ;
14822 int ecode4 = 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 PyObject * obj3 = 0 ;
14827 char * kwnames[] = {
14828 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14829 };
14830
14831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14833 if (!SWIG_IsOK(res1)) {
14834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14835 }
14836 arg1 = reinterpret_cast< wxImage * >(argp1);
14837 {
14838 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14839 arg2 = temp2->m_wxis;
14840 created2 = false;
14841 } else {
14842 PyErr_Clear(); // clear the failure of the wxPyConvert above
14843 arg2 = wxPyCBInputStream_create(obj1, false);
14844 if (arg2 == NULL) {
14845 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14846 SWIG_fail;
14847 }
14848 created2 = true;
14849 }
14850 }
14851 if (obj2) {
14852 ecode3 = SWIG_AsVal_long(obj2, &val3);
14853 if (!SWIG_IsOK(ecode3)) {
14854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14855 }
14856 arg3 = static_cast< long >(val3);
14857 }
14858 if (obj3) {
14859 ecode4 = SWIG_AsVal_int(obj3, &val4);
14860 if (!SWIG_IsOK(ecode4)) {
14861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14862 }
14863 arg4 = static_cast< int >(val4);
14864 }
14865 {
14866 PyThreadState* __tstate = wxPyBeginAllowThreads();
14867 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14868 wxPyEndAllowThreads(__tstate);
14869 if (PyErr_Occurred()) SWIG_fail;
14870 }
14871 {
14872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14873 }
14874 {
14875 if (created2) delete arg2;
14876 }
14877 return resultobj;
14878 fail:
14879 {
14880 if (created2) delete arg2;
14881 }
14882 return NULL;
14883 }
14884
14885
14886 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14887 PyObject *resultobj = 0;
14888 wxImage *arg1 = (wxImage *) 0 ;
14889 wxInputStream *arg2 = 0 ;
14890 wxString *arg3 = 0 ;
14891 int arg4 = (int) -1 ;
14892 bool result;
14893 void *argp1 = 0 ;
14894 int res1 = 0 ;
14895 wxPyInputStream *temp2 ;
14896 bool created2 ;
14897 bool temp3 = false ;
14898 int val4 ;
14899 int ecode4 = 0 ;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 PyObject * obj2 = 0 ;
14903 PyObject * obj3 = 0 ;
14904 char * kwnames[] = {
14905 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14906 };
14907
14908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImage * >(argp1);
14914 {
14915 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14916 arg2 = temp2->m_wxis;
14917 created2 = false;
14918 } else {
14919 PyErr_Clear(); // clear the failure of the wxPyConvert above
14920 arg2 = wxPyCBInputStream_create(obj1, false);
14921 if (arg2 == NULL) {
14922 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14923 SWIG_fail;
14924 }
14925 created2 = true;
14926 }
14927 }
14928 {
14929 arg3 = wxString_in_helper(obj2);
14930 if (arg3 == NULL) SWIG_fail;
14931 temp3 = true;
14932 }
14933 if (obj3) {
14934 ecode4 = SWIG_AsVal_int(obj3, &val4);
14935 if (!SWIG_IsOK(ecode4)) {
14936 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14937 }
14938 arg4 = static_cast< int >(val4);
14939 }
14940 {
14941 PyThreadState* __tstate = wxPyBeginAllowThreads();
14942 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 {
14947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14948 }
14949 {
14950 if (created2) delete arg2;
14951 }
14952 {
14953 if (temp3)
14954 delete arg3;
14955 }
14956 return resultobj;
14957 fail:
14958 {
14959 if (created2) delete arg2;
14960 }
14961 {
14962 if (temp3)
14963 delete arg3;
14964 }
14965 return NULL;
14966 }
14967
14968
14969 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14970 PyObject *resultobj = 0;
14971 wxImage *arg1 = (wxImage *) 0 ;
14972 bool result;
14973 void *argp1 = 0 ;
14974 int res1 = 0 ;
14975 PyObject *swig_obj[1] ;
14976
14977 if (!args) SWIG_fail;
14978 swig_obj[0] = args;
14979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14980 if (!SWIG_IsOK(res1)) {
14981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14982 }
14983 arg1 = reinterpret_cast< wxImage * >(argp1);
14984 {
14985 PyThreadState* __tstate = wxPyBeginAllowThreads();
14986 result = (bool)(arg1)->Ok();
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 {
14991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14992 }
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15000 PyObject *resultobj = 0;
15001 wxImage *arg1 = (wxImage *) 0 ;
15002 int result;
15003 void *argp1 = 0 ;
15004 int res1 = 0 ;
15005 PyObject *swig_obj[1] ;
15006
15007 if (!args) SWIG_fail;
15008 swig_obj[0] = args;
15009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15010 if (!SWIG_IsOK(res1)) {
15011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15012 }
15013 arg1 = reinterpret_cast< wxImage * >(argp1);
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (int)(arg1)->GetWidth();
15017 wxPyEndAllowThreads(__tstate);
15018 if (PyErr_Occurred()) SWIG_fail;
15019 }
15020 resultobj = SWIG_From_int(static_cast< int >(result));
15021 return resultobj;
15022 fail:
15023 return NULL;
15024 }
15025
15026
15027 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 PyObject *resultobj = 0;
15029 wxImage *arg1 = (wxImage *) 0 ;
15030 int result;
15031 void *argp1 = 0 ;
15032 int res1 = 0 ;
15033 PyObject *swig_obj[1] ;
15034
15035 if (!args) SWIG_fail;
15036 swig_obj[0] = args;
15037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15038 if (!SWIG_IsOK(res1)) {
15039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15040 }
15041 arg1 = reinterpret_cast< wxImage * >(argp1);
15042 {
15043 PyThreadState* __tstate = wxPyBeginAllowThreads();
15044 result = (int)(arg1)->GetHeight();
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 resultobj = SWIG_From_int(static_cast< int >(result));
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15056 PyObject *resultobj = 0;
15057 wxImage *arg1 = (wxImage *) 0 ;
15058 wxSize result;
15059 void *argp1 = 0 ;
15060 int res1 = 0 ;
15061 PyObject *swig_obj[1] ;
15062
15063 if (!args) SWIG_fail;
15064 swig_obj[0] = args;
15065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15066 if (!SWIG_IsOK(res1)) {
15067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15068 }
15069 arg1 = reinterpret_cast< wxImage * >(argp1);
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 result = wxImage_GetSize(arg1);
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15077 return resultobj;
15078 fail:
15079 return NULL;
15080 }
15081
15082
15083 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15084 PyObject *resultobj = 0;
15085 wxImage *arg1 = (wxImage *) 0 ;
15086 wxRect *arg2 = 0 ;
15087 SwigValueWrapper<wxImage > result;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 wxRect temp2 ;
15091 PyObject * obj0 = 0 ;
15092 PyObject * obj1 = 0 ;
15093 char * kwnames[] = {
15094 (char *) "self",(char *) "rect", NULL
15095 };
15096
15097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15099 if (!SWIG_IsOK(res1)) {
15100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15101 }
15102 arg1 = reinterpret_cast< wxImage * >(argp1);
15103 {
15104 arg2 = &temp2;
15105 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15106 }
15107 {
15108 PyThreadState* __tstate = wxPyBeginAllowThreads();
15109 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj = 0;
15122 wxImage *arg1 = (wxImage *) 0 ;
15123 wxSize *arg2 = 0 ;
15124 wxPoint *arg3 = 0 ;
15125 int arg4 = (int) -1 ;
15126 int arg5 = (int) -1 ;
15127 int arg6 = (int) -1 ;
15128 SwigValueWrapper<wxImage > result;
15129 void *argp1 = 0 ;
15130 int res1 = 0 ;
15131 wxSize temp2 ;
15132 wxPoint temp3 ;
15133 int val4 ;
15134 int ecode4 = 0 ;
15135 int val5 ;
15136 int ecode5 = 0 ;
15137 int val6 ;
15138 int ecode6 = 0 ;
15139 PyObject * obj0 = 0 ;
15140 PyObject * obj1 = 0 ;
15141 PyObject * obj2 = 0 ;
15142 PyObject * obj3 = 0 ;
15143 PyObject * obj4 = 0 ;
15144 PyObject * obj5 = 0 ;
15145 char * kwnames[] = {
15146 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15147 };
15148
15149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15151 if (!SWIG_IsOK(res1)) {
15152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15153 }
15154 arg1 = reinterpret_cast< wxImage * >(argp1);
15155 {
15156 arg2 = &temp2;
15157 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15158 }
15159 {
15160 arg3 = &temp3;
15161 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15162 }
15163 if (obj3) {
15164 ecode4 = SWIG_AsVal_int(obj3, &val4);
15165 if (!SWIG_IsOK(ecode4)) {
15166 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15167 }
15168 arg4 = static_cast< int >(val4);
15169 }
15170 if (obj4) {
15171 ecode5 = SWIG_AsVal_int(obj4, &val5);
15172 if (!SWIG_IsOK(ecode5)) {
15173 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15174 }
15175 arg5 = static_cast< int >(val5);
15176 }
15177 if (obj5) {
15178 ecode6 = SWIG_AsVal_int(obj5, &val6);
15179 if (!SWIG_IsOK(ecode6)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15181 }
15182 arg6 = static_cast< int >(val6);
15183 }
15184 {
15185 PyThreadState* __tstate = wxPyBeginAllowThreads();
15186 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15187 wxPyEndAllowThreads(__tstate);
15188 if (PyErr_Occurred()) SWIG_fail;
15189 }
15190 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15191 return resultobj;
15192 fail:
15193 return NULL;
15194 }
15195
15196
15197 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15198 PyObject *resultobj = 0;
15199 wxImage *arg1 = (wxImage *) 0 ;
15200 SwigValueWrapper<wxImage > result;
15201 void *argp1 = 0 ;
15202 int res1 = 0 ;
15203 PyObject *swig_obj[1] ;
15204
15205 if (!args) SWIG_fail;
15206 swig_obj[0] = args;
15207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15208 if (!SWIG_IsOK(res1)) {
15209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15210 }
15211 arg1 = reinterpret_cast< wxImage * >(argp1);
15212 {
15213 PyThreadState* __tstate = wxPyBeginAllowThreads();
15214 result = (arg1)->Copy();
15215 wxPyEndAllowThreads(__tstate);
15216 if (PyErr_Occurred()) SWIG_fail;
15217 }
15218 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj = 0;
15227 wxImage *arg1 = (wxImage *) 0 ;
15228 wxImage *arg2 = 0 ;
15229 int arg3 ;
15230 int arg4 ;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 void *argp2 = 0 ;
15234 int res2 = 0 ;
15235 int val3 ;
15236 int ecode3 = 0 ;
15237 int val4 ;
15238 int ecode4 = 0 ;
15239 PyObject * obj0 = 0 ;
15240 PyObject * obj1 = 0 ;
15241 PyObject * obj2 = 0 ;
15242 PyObject * obj3 = 0 ;
15243 char * kwnames[] = {
15244 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15245 };
15246
15247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15249 if (!SWIG_IsOK(res1)) {
15250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15251 }
15252 arg1 = reinterpret_cast< wxImage * >(argp1);
15253 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15254 if (!SWIG_IsOK(res2)) {
15255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15256 }
15257 if (!argp2) {
15258 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15259 }
15260 arg2 = reinterpret_cast< wxImage * >(argp2);
15261 ecode3 = SWIG_AsVal_int(obj2, &val3);
15262 if (!SWIG_IsOK(ecode3)) {
15263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15264 }
15265 arg3 = static_cast< int >(val3);
15266 ecode4 = SWIG_AsVal_int(obj3, &val4);
15267 if (!SWIG_IsOK(ecode4)) {
15268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15269 }
15270 arg4 = static_cast< int >(val4);
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15274 wxPyEndAllowThreads(__tstate);
15275 if (PyErr_Occurred()) SWIG_fail;
15276 }
15277 resultobj = SWIG_Py_Void();
15278 return resultobj;
15279 fail:
15280 return NULL;
15281 }
15282
15283
15284 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15285 PyObject *resultobj = 0;
15286 wxImage *arg1 = (wxImage *) 0 ;
15287 PyObject *result = 0 ;
15288 void *argp1 = 0 ;
15289 int res1 = 0 ;
15290 PyObject *swig_obj[1] ;
15291
15292 if (!args) SWIG_fail;
15293 swig_obj[0] = args;
15294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15295 if (!SWIG_IsOK(res1)) {
15296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15297 }
15298 arg1 = reinterpret_cast< wxImage * >(argp1);
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = (PyObject *)wxImage_GetData(arg1);
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = result;
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15313 PyObject *resultobj = 0;
15314 wxImage *arg1 = (wxImage *) 0 ;
15315 buffer arg2 ;
15316 int arg3 ;
15317 void *argp1 = 0 ;
15318 int res1 = 0 ;
15319 PyObject * obj0 = 0 ;
15320 PyObject * obj1 = 0 ;
15321 char * kwnames[] = {
15322 (char *) "self",(char *) "data", NULL
15323 };
15324
15325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15327 if (!SWIG_IsOK(res1)) {
15328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15329 }
15330 arg1 = reinterpret_cast< wxImage * >(argp1);
15331 {
15332 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15333 }
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 wxImage_SetData(arg1,arg2,arg3);
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 resultobj = SWIG_Py_Void();
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15348 PyObject *resultobj = 0;
15349 wxImage *arg1 = (wxImage *) 0 ;
15350 PyObject *result = 0 ;
15351 void *argp1 = 0 ;
15352 int res1 = 0 ;
15353 PyObject *swig_obj[1] ;
15354
15355 if (!args) SWIG_fail;
15356 swig_obj[0] = args;
15357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15358 if (!SWIG_IsOK(res1)) {
15359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15360 }
15361 arg1 = reinterpret_cast< wxImage * >(argp1);
15362 {
15363 PyThreadState* __tstate = wxPyBeginAllowThreads();
15364 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15365 wxPyEndAllowThreads(__tstate);
15366 if (PyErr_Occurred()) SWIG_fail;
15367 }
15368 resultobj = result;
15369 return resultobj;
15370 fail:
15371 return NULL;
15372 }
15373
15374
15375 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15376 PyObject *resultobj = 0;
15377 wxImage *arg1 = (wxImage *) 0 ;
15378 buffer arg2 ;
15379 int arg3 ;
15380 void *argp1 = 0 ;
15381 int res1 = 0 ;
15382 PyObject * obj0 = 0 ;
15383 PyObject * obj1 = 0 ;
15384 char * kwnames[] = {
15385 (char *) "self",(char *) "data", NULL
15386 };
15387
15388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15390 if (!SWIG_IsOK(res1)) {
15391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15392 }
15393 arg1 = reinterpret_cast< wxImage * >(argp1);
15394 {
15395 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15396 }
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 wxImage_SetDataBuffer(arg1,arg2,arg3);
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 resultobj = SWIG_Py_Void();
15404 return resultobj;
15405 fail:
15406 return NULL;
15407 }
15408
15409
15410 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15411 PyObject *resultobj = 0;
15412 wxImage *arg1 = (wxImage *) 0 ;
15413 PyObject *result = 0 ;
15414 void *argp1 = 0 ;
15415 int res1 = 0 ;
15416 PyObject *swig_obj[1] ;
15417
15418 if (!args) SWIG_fail;
15419 swig_obj[0] = args;
15420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15421 if (!SWIG_IsOK(res1)) {
15422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15423 }
15424 arg1 = reinterpret_cast< wxImage * >(argp1);
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 result = (PyObject *)wxImage_GetAlphaData(arg1);
15428 wxPyEndAllowThreads(__tstate);
15429 if (PyErr_Occurred()) SWIG_fail;
15430 }
15431 resultobj = result;
15432 return resultobj;
15433 fail:
15434 return NULL;
15435 }
15436
15437
15438 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15439 PyObject *resultobj = 0;
15440 wxImage *arg1 = (wxImage *) 0 ;
15441 buffer arg2 ;
15442 int arg3 ;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 PyObject * obj0 = 0 ;
15446 PyObject * obj1 = 0 ;
15447 char * kwnames[] = {
15448 (char *) "self",(char *) "alpha", NULL
15449 };
15450
15451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15453 if (!SWIG_IsOK(res1)) {
15454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15455 }
15456 arg1 = reinterpret_cast< wxImage * >(argp1);
15457 {
15458 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15459 }
15460 {
15461 PyThreadState* __tstate = wxPyBeginAllowThreads();
15462 wxImage_SetAlphaData(arg1,arg2,arg3);
15463 wxPyEndAllowThreads(__tstate);
15464 if (PyErr_Occurred()) SWIG_fail;
15465 }
15466 resultobj = SWIG_Py_Void();
15467 return resultobj;
15468 fail:
15469 return NULL;
15470 }
15471
15472
15473 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15474 PyObject *resultobj = 0;
15475 wxImage *arg1 = (wxImage *) 0 ;
15476 PyObject *result = 0 ;
15477 void *argp1 = 0 ;
15478 int res1 = 0 ;
15479 PyObject *swig_obj[1] ;
15480
15481 if (!args) SWIG_fail;
15482 swig_obj[0] = args;
15483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15484 if (!SWIG_IsOK(res1)) {
15485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15486 }
15487 arg1 = reinterpret_cast< wxImage * >(argp1);
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15491 wxPyEndAllowThreads(__tstate);
15492 if (PyErr_Occurred()) SWIG_fail;
15493 }
15494 resultobj = result;
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15502 PyObject *resultobj = 0;
15503 wxImage *arg1 = (wxImage *) 0 ;
15504 buffer arg2 ;
15505 int arg3 ;
15506 void *argp1 = 0 ;
15507 int res1 = 0 ;
15508 PyObject * obj0 = 0 ;
15509 PyObject * obj1 = 0 ;
15510 char * kwnames[] = {
15511 (char *) "self",(char *) "alpha", NULL
15512 };
15513
15514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15516 if (!SWIG_IsOK(res1)) {
15517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15518 }
15519 arg1 = reinterpret_cast< wxImage * >(argp1);
15520 {
15521 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15522 }
15523 {
15524 PyThreadState* __tstate = wxPyBeginAllowThreads();
15525 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 resultobj = SWIG_Py_Void();
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj = 0;
15538 wxImage *arg1 = (wxImage *) 0 ;
15539 byte arg2 ;
15540 byte arg3 ;
15541 byte arg4 ;
15542 void *argp1 = 0 ;
15543 int res1 = 0 ;
15544 unsigned char val2 ;
15545 int ecode2 = 0 ;
15546 unsigned char val3 ;
15547 int ecode3 = 0 ;
15548 unsigned char val4 ;
15549 int ecode4 = 0 ;
15550 PyObject * obj0 = 0 ;
15551 PyObject * obj1 = 0 ;
15552 PyObject * obj2 = 0 ;
15553 PyObject * obj3 = 0 ;
15554 char * kwnames[] = {
15555 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15556 };
15557
15558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15560 if (!SWIG_IsOK(res1)) {
15561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15562 }
15563 arg1 = reinterpret_cast< wxImage * >(argp1);
15564 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15565 if (!SWIG_IsOK(ecode2)) {
15566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15567 }
15568 arg2 = static_cast< byte >(val2);
15569 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15570 if (!SWIG_IsOK(ecode3)) {
15571 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15572 }
15573 arg3 = static_cast< byte >(val3);
15574 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15575 if (!SWIG_IsOK(ecode4)) {
15576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15577 }
15578 arg4 = static_cast< byte >(val4);
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 (arg1)->SetMaskColour(arg2,arg3,arg4);
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_Py_Void();
15586 return resultobj;
15587 fail:
15588 return NULL;
15589 }
15590
15591
15592 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15593 PyObject *resultobj = 0;
15594 wxImage *arg1 = (wxImage *) 0 ;
15595 byte *arg2 = (byte *) 0 ;
15596 byte *arg3 = (byte *) 0 ;
15597 byte *arg4 = (byte *) 0 ;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 byte temp2 ;
15601 int res2 = SWIG_TMPOBJ ;
15602 byte temp3 ;
15603 int res3 = SWIG_TMPOBJ ;
15604 byte temp4 ;
15605 int res4 = SWIG_TMPOBJ ;
15606 PyObject *swig_obj[1] ;
15607
15608 arg2 = &temp2;
15609 arg3 = &temp3;
15610 arg4 = &temp4;
15611 if (!args) SWIG_fail;
15612 swig_obj[0] = args;
15613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15614 if (!SWIG_IsOK(res1)) {
15615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15616 }
15617 arg1 = reinterpret_cast< wxImage * >(argp1);
15618 {
15619 PyThreadState* __tstate = wxPyBeginAllowThreads();
15620 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15621 wxPyEndAllowThreads(__tstate);
15622 if (PyErr_Occurred()) SWIG_fail;
15623 }
15624 resultobj = SWIG_Py_Void();
15625 if (SWIG_IsTmpObj(res2)) {
15626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15627 } else {
15628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15630 }
15631 if (SWIG_IsTmpObj(res3)) {
15632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15633 } else {
15634 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15636 }
15637 if (SWIG_IsTmpObj(res4)) {
15638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15639 } else {
15640 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15642 }
15643 return resultobj;
15644 fail:
15645 return NULL;
15646 }
15647
15648
15649 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15650 PyObject *resultobj = 0;
15651 wxImage *arg1 = (wxImage *) 0 ;
15652 byte result;
15653 void *argp1 = 0 ;
15654 int res1 = 0 ;
15655 PyObject *swig_obj[1] ;
15656
15657 if (!args) SWIG_fail;
15658 swig_obj[0] = args;
15659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15660 if (!SWIG_IsOK(res1)) {
15661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15662 }
15663 arg1 = reinterpret_cast< wxImage * >(argp1);
15664 {
15665 PyThreadState* __tstate = wxPyBeginAllowThreads();
15666 result = (byte)(arg1)->GetMaskRed();
15667 wxPyEndAllowThreads(__tstate);
15668 if (PyErr_Occurred()) SWIG_fail;
15669 }
15670 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15678 PyObject *resultobj = 0;
15679 wxImage *arg1 = (wxImage *) 0 ;
15680 byte result;
15681 void *argp1 = 0 ;
15682 int res1 = 0 ;
15683 PyObject *swig_obj[1] ;
15684
15685 if (!args) SWIG_fail;
15686 swig_obj[0] = args;
15687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15688 if (!SWIG_IsOK(res1)) {
15689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15690 }
15691 arg1 = reinterpret_cast< wxImage * >(argp1);
15692 {
15693 PyThreadState* __tstate = wxPyBeginAllowThreads();
15694 result = (byte)(arg1)->GetMaskGreen();
15695 wxPyEndAllowThreads(__tstate);
15696 if (PyErr_Occurred()) SWIG_fail;
15697 }
15698 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15699 return resultobj;
15700 fail:
15701 return NULL;
15702 }
15703
15704
15705 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15706 PyObject *resultobj = 0;
15707 wxImage *arg1 = (wxImage *) 0 ;
15708 byte result;
15709 void *argp1 = 0 ;
15710 int res1 = 0 ;
15711 PyObject *swig_obj[1] ;
15712
15713 if (!args) SWIG_fail;
15714 swig_obj[0] = args;
15715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15716 if (!SWIG_IsOK(res1)) {
15717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15718 }
15719 arg1 = reinterpret_cast< wxImage * >(argp1);
15720 {
15721 PyThreadState* __tstate = wxPyBeginAllowThreads();
15722 result = (byte)(arg1)->GetMaskBlue();
15723 wxPyEndAllowThreads(__tstate);
15724 if (PyErr_Occurred()) SWIG_fail;
15725 }
15726 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15727 return resultobj;
15728 fail:
15729 return NULL;
15730 }
15731
15732
15733 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15734 PyObject *resultobj = 0;
15735 wxImage *arg1 = (wxImage *) 0 ;
15736 bool arg2 = (bool) true ;
15737 void *argp1 = 0 ;
15738 int res1 = 0 ;
15739 bool val2 ;
15740 int ecode2 = 0 ;
15741 PyObject * obj0 = 0 ;
15742 PyObject * obj1 = 0 ;
15743 char * kwnames[] = {
15744 (char *) "self",(char *) "mask", NULL
15745 };
15746
15747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15749 if (!SWIG_IsOK(res1)) {
15750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15751 }
15752 arg1 = reinterpret_cast< wxImage * >(argp1);
15753 if (obj1) {
15754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15755 if (!SWIG_IsOK(ecode2)) {
15756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15757 }
15758 arg2 = static_cast< bool >(val2);
15759 }
15760 {
15761 PyThreadState* __tstate = wxPyBeginAllowThreads();
15762 (arg1)->SetMask(arg2);
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 resultobj = SWIG_Py_Void();
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15774 PyObject *resultobj = 0;
15775 wxImage *arg1 = (wxImage *) 0 ;
15776 bool result;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 PyObject *swig_obj[1] ;
15780
15781 if (!args) SWIG_fail;
15782 swig_obj[0] = args;
15783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15784 if (!SWIG_IsOK(res1)) {
15785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15786 }
15787 arg1 = reinterpret_cast< wxImage * >(argp1);
15788 {
15789 PyThreadState* __tstate = wxPyBeginAllowThreads();
15790 result = (bool)(arg1)->HasMask();
15791 wxPyEndAllowThreads(__tstate);
15792 if (PyErr_Occurred()) SWIG_fail;
15793 }
15794 {
15795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15796 }
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15804 PyObject *resultobj = 0;
15805 wxImage *arg1 = (wxImage *) 0 ;
15806 double arg2 ;
15807 wxPoint *arg3 = 0 ;
15808 bool arg4 = (bool) true ;
15809 wxPoint *arg5 = (wxPoint *) NULL ;
15810 SwigValueWrapper<wxImage > result;
15811 void *argp1 = 0 ;
15812 int res1 = 0 ;
15813 double val2 ;
15814 int ecode2 = 0 ;
15815 wxPoint temp3 ;
15816 bool val4 ;
15817 int ecode4 = 0 ;
15818 void *argp5 = 0 ;
15819 int res5 = 0 ;
15820 PyObject * obj0 = 0 ;
15821 PyObject * obj1 = 0 ;
15822 PyObject * obj2 = 0 ;
15823 PyObject * obj3 = 0 ;
15824 PyObject * obj4 = 0 ;
15825 char * kwnames[] = {
15826 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15827 };
15828
15829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage * >(argp1);
15835 ecode2 = SWIG_AsVal_double(obj1, &val2);
15836 if (!SWIG_IsOK(ecode2)) {
15837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15838 }
15839 arg2 = static_cast< double >(val2);
15840 {
15841 arg3 = &temp3;
15842 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15843 }
15844 if (obj3) {
15845 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15846 if (!SWIG_IsOK(ecode4)) {
15847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15848 }
15849 arg4 = static_cast< bool >(val4);
15850 }
15851 if (obj4) {
15852 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15853 if (!SWIG_IsOK(res5)) {
15854 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15855 }
15856 arg5 = reinterpret_cast< wxPoint * >(argp5);
15857 }
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15861 wxPyEndAllowThreads(__tstate);
15862 if (PyErr_Occurred()) SWIG_fail;
15863 }
15864 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15872 PyObject *resultobj = 0;
15873 wxImage *arg1 = (wxImage *) 0 ;
15874 bool arg2 = (bool) true ;
15875 SwigValueWrapper<wxImage > result;
15876 void *argp1 = 0 ;
15877 int res1 = 0 ;
15878 bool val2 ;
15879 int ecode2 = 0 ;
15880 PyObject * obj0 = 0 ;
15881 PyObject * obj1 = 0 ;
15882 char * kwnames[] = {
15883 (char *) "self",(char *) "clockwise", NULL
15884 };
15885
15886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15888 if (!SWIG_IsOK(res1)) {
15889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15890 }
15891 arg1 = reinterpret_cast< wxImage * >(argp1);
15892 if (obj1) {
15893 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15894 if (!SWIG_IsOK(ecode2)) {
15895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15896 }
15897 arg2 = static_cast< bool >(val2);
15898 }
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (arg1)->Rotate90(arg2);
15902 wxPyEndAllowThreads(__tstate);
15903 if (PyErr_Occurred()) SWIG_fail;
15904 }
15905 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = 0;
15914 wxImage *arg1 = (wxImage *) 0 ;
15915 bool arg2 = (bool) true ;
15916 SwigValueWrapper<wxImage > result;
15917 void *argp1 = 0 ;
15918 int res1 = 0 ;
15919 bool val2 ;
15920 int ecode2 = 0 ;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 char * kwnames[] = {
15924 (char *) "self",(char *) "horizontally", NULL
15925 };
15926
15927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15929 if (!SWIG_IsOK(res1)) {
15930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15931 }
15932 arg1 = reinterpret_cast< wxImage * >(argp1);
15933 if (obj1) {
15934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15935 if (!SWIG_IsOK(ecode2)) {
15936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15937 }
15938 arg2 = static_cast< bool >(val2);
15939 }
15940 {
15941 PyThreadState* __tstate = wxPyBeginAllowThreads();
15942 result = (arg1)->Mirror(arg2);
15943 wxPyEndAllowThreads(__tstate);
15944 if (PyErr_Occurred()) SWIG_fail;
15945 }
15946 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15954 PyObject *resultobj = 0;
15955 wxImage *arg1 = (wxImage *) 0 ;
15956 byte arg2 ;
15957 byte arg3 ;
15958 byte arg4 ;
15959 byte arg5 ;
15960 byte arg6 ;
15961 byte arg7 ;
15962 void *argp1 = 0 ;
15963 int res1 = 0 ;
15964 unsigned char val2 ;
15965 int ecode2 = 0 ;
15966 unsigned char val3 ;
15967 int ecode3 = 0 ;
15968 unsigned char val4 ;
15969 int ecode4 = 0 ;
15970 unsigned char val5 ;
15971 int ecode5 = 0 ;
15972 unsigned char val6 ;
15973 int ecode6 = 0 ;
15974 unsigned char val7 ;
15975 int ecode7 = 0 ;
15976 PyObject * obj0 = 0 ;
15977 PyObject * obj1 = 0 ;
15978 PyObject * obj2 = 0 ;
15979 PyObject * obj3 = 0 ;
15980 PyObject * obj4 = 0 ;
15981 PyObject * obj5 = 0 ;
15982 PyObject * obj6 = 0 ;
15983 char * kwnames[] = {
15984 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15985 };
15986
15987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15991 }
15992 arg1 = reinterpret_cast< wxImage * >(argp1);
15993 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15996 }
15997 arg2 = static_cast< byte >(val2);
15998 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15999 if (!SWIG_IsOK(ecode3)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16001 }
16002 arg3 = static_cast< byte >(val3);
16003 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16004 if (!SWIG_IsOK(ecode4)) {
16005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16006 }
16007 arg4 = static_cast< byte >(val4);
16008 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16009 if (!SWIG_IsOK(ecode5)) {
16010 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16011 }
16012 arg5 = static_cast< byte >(val5);
16013 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16014 if (!SWIG_IsOK(ecode6)) {
16015 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16016 }
16017 arg6 = static_cast< byte >(val6);
16018 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16019 if (!SWIG_IsOK(ecode7)) {
16020 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16021 }
16022 arg7 = static_cast< byte >(val7);
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16026 wxPyEndAllowThreads(__tstate);
16027 if (PyErr_Occurred()) SWIG_fail;
16028 }
16029 resultobj = SWIG_Py_Void();
16030 return resultobj;
16031 fail:
16032 return NULL;
16033 }
16034
16035
16036 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16037 PyObject *resultobj = 0;
16038 wxImage *arg1 = (wxImage *) 0 ;
16039 double arg2 = (double) 0.299 ;
16040 double arg3 = (double) 0.587 ;
16041 double arg4 = (double) 0.114 ;
16042 SwigValueWrapper<wxImage > result;
16043 void *argp1 = 0 ;
16044 int res1 = 0 ;
16045 double val2 ;
16046 int ecode2 = 0 ;
16047 double val3 ;
16048 int ecode3 = 0 ;
16049 double val4 ;
16050 int ecode4 = 0 ;
16051 PyObject * obj0 = 0 ;
16052 PyObject * obj1 = 0 ;
16053 PyObject * obj2 = 0 ;
16054 PyObject * obj3 = 0 ;
16055 char * kwnames[] = {
16056 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16057 };
16058
16059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16061 if (!SWIG_IsOK(res1)) {
16062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16063 }
16064 arg1 = reinterpret_cast< wxImage * >(argp1);
16065 if (obj1) {
16066 ecode2 = SWIG_AsVal_double(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16069 }
16070 arg2 = static_cast< double >(val2);
16071 }
16072 if (obj2) {
16073 ecode3 = SWIG_AsVal_double(obj2, &val3);
16074 if (!SWIG_IsOK(ecode3)) {
16075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16076 }
16077 arg3 = static_cast< double >(val3);
16078 }
16079 if (obj3) {
16080 ecode4 = SWIG_AsVal_double(obj3, &val4);
16081 if (!SWIG_IsOK(ecode4)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16083 }
16084 arg4 = static_cast< double >(val4);
16085 }
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16089 wxPyEndAllowThreads(__tstate);
16090 if (PyErr_Occurred()) SWIG_fail;
16091 }
16092 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16093 return resultobj;
16094 fail:
16095 return NULL;
16096 }
16097
16098
16099 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16100 PyObject *resultobj = 0;
16101 wxImage *arg1 = (wxImage *) 0 ;
16102 byte arg2 ;
16103 byte arg3 ;
16104 byte arg4 ;
16105 SwigValueWrapper<wxImage > result;
16106 void *argp1 = 0 ;
16107 int res1 = 0 ;
16108 unsigned char val2 ;
16109 int ecode2 = 0 ;
16110 unsigned char val3 ;
16111 int ecode3 = 0 ;
16112 unsigned char val4 ;
16113 int ecode4 = 0 ;
16114 PyObject * obj0 = 0 ;
16115 PyObject * obj1 = 0 ;
16116 PyObject * obj2 = 0 ;
16117 PyObject * obj3 = 0 ;
16118 char * kwnames[] = {
16119 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16120 };
16121
16122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16124 if (!SWIG_IsOK(res1)) {
16125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16126 }
16127 arg1 = reinterpret_cast< wxImage * >(argp1);
16128 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16129 if (!SWIG_IsOK(ecode2)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16131 }
16132 arg2 = static_cast< byte >(val2);
16133 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16134 if (!SWIG_IsOK(ecode3)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16136 }
16137 arg3 = static_cast< byte >(val3);
16138 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16139 if (!SWIG_IsOK(ecode4)) {
16140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16141 }
16142 arg4 = static_cast< byte >(val4);
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj = 0;
16158 wxImage *arg1 = (wxImage *) 0 ;
16159 wxString *arg2 = 0 ;
16160 wxString *arg3 = 0 ;
16161 void *argp1 = 0 ;
16162 int res1 = 0 ;
16163 bool temp2 = false ;
16164 bool temp3 = false ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 PyObject * obj2 = 0 ;
16168 char * kwnames[] = {
16169 (char *) "self",(char *) "name",(char *) "value", NULL
16170 };
16171
16172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16174 if (!SWIG_IsOK(res1)) {
16175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16176 }
16177 arg1 = reinterpret_cast< wxImage * >(argp1);
16178 {
16179 arg2 = wxString_in_helper(obj1);
16180 if (arg2 == NULL) SWIG_fail;
16181 temp2 = true;
16182 }
16183 {
16184 arg3 = wxString_in_helper(obj2);
16185 if (arg3 == NULL) SWIG_fail;
16186 temp3 = true;
16187 }
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16191 wxPyEndAllowThreads(__tstate);
16192 if (PyErr_Occurred()) SWIG_fail;
16193 }
16194 resultobj = SWIG_Py_Void();
16195 {
16196 if (temp2)
16197 delete arg2;
16198 }
16199 {
16200 if (temp3)
16201 delete arg3;
16202 }
16203 return resultobj;
16204 fail:
16205 {
16206 if (temp2)
16207 delete arg2;
16208 }
16209 {
16210 if (temp3)
16211 delete arg3;
16212 }
16213 return NULL;
16214 }
16215
16216
16217 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16218 PyObject *resultobj = 0;
16219 wxImage *arg1 = (wxImage *) 0 ;
16220 wxString *arg2 = 0 ;
16221 int arg3 ;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 bool temp2 = false ;
16225 int val3 ;
16226 int ecode3 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 char * kwnames[] = {
16231 (char *) "self",(char *) "name",(char *) "value", NULL
16232 };
16233
16234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16236 if (!SWIG_IsOK(res1)) {
16237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16238 }
16239 arg1 = reinterpret_cast< wxImage * >(argp1);
16240 {
16241 arg2 = wxString_in_helper(obj1);
16242 if (arg2 == NULL) SWIG_fail;
16243 temp2 = true;
16244 }
16245 ecode3 = SWIG_AsVal_int(obj2, &val3);
16246 if (!SWIG_IsOK(ecode3)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16248 }
16249 arg3 = static_cast< int >(val3);
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 (arg1)->SetOption((wxString const &)*arg2,arg3);
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_Py_Void();
16257 {
16258 if (temp2)
16259 delete arg2;
16260 }
16261 return resultobj;
16262 fail:
16263 {
16264 if (temp2)
16265 delete arg2;
16266 }
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 wxString *arg2 = 0 ;
16275 wxString result;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 bool temp2 = false ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 char * kwnames[] = {
16282 (char *) "self",(char *) "name", NULL
16283 };
16284
16285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16289 }
16290 arg1 = reinterpret_cast< wxImage * >(argp1);
16291 {
16292 arg2 = wxString_in_helper(obj1);
16293 if (arg2 == NULL) SWIG_fail;
16294 temp2 = true;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 #if wxUSE_UNICODE
16304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16305 #else
16306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16307 #endif
16308 }
16309 {
16310 if (temp2)
16311 delete arg2;
16312 }
16313 return resultobj;
16314 fail:
16315 {
16316 if (temp2)
16317 delete arg2;
16318 }
16319 return NULL;
16320 }
16321
16322
16323 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16324 PyObject *resultobj = 0;
16325 wxImage *arg1 = (wxImage *) 0 ;
16326 wxString *arg2 = 0 ;
16327 int result;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 bool temp2 = false ;
16331 PyObject * obj0 = 0 ;
16332 PyObject * obj1 = 0 ;
16333 char * kwnames[] = {
16334 (char *) "self",(char *) "name", NULL
16335 };
16336
16337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16339 if (!SWIG_IsOK(res1)) {
16340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16341 }
16342 arg1 = reinterpret_cast< wxImage * >(argp1);
16343 {
16344 arg2 = wxString_in_helper(obj1);
16345 if (arg2 == NULL) SWIG_fail;
16346 temp2 = true;
16347 }
16348 {
16349 PyThreadState* __tstate = wxPyBeginAllowThreads();
16350 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16351 wxPyEndAllowThreads(__tstate);
16352 if (PyErr_Occurred()) SWIG_fail;
16353 }
16354 resultobj = SWIG_From_int(static_cast< int >(result));
16355 {
16356 if (temp2)
16357 delete arg2;
16358 }
16359 return resultobj;
16360 fail:
16361 {
16362 if (temp2)
16363 delete arg2;
16364 }
16365 return NULL;
16366 }
16367
16368
16369 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16370 PyObject *resultobj = 0;
16371 wxImage *arg1 = (wxImage *) 0 ;
16372 wxString *arg2 = 0 ;
16373 bool result;
16374 void *argp1 = 0 ;
16375 int res1 = 0 ;
16376 bool temp2 = false ;
16377 PyObject * obj0 = 0 ;
16378 PyObject * obj1 = 0 ;
16379 char * kwnames[] = {
16380 (char *) "self",(char *) "name", NULL
16381 };
16382
16383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16385 if (!SWIG_IsOK(res1)) {
16386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16387 }
16388 arg1 = reinterpret_cast< wxImage * >(argp1);
16389 {
16390 arg2 = wxString_in_helper(obj1);
16391 if (arg2 == NULL) SWIG_fail;
16392 temp2 = true;
16393 }
16394 {
16395 PyThreadState* __tstate = wxPyBeginAllowThreads();
16396 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16397 wxPyEndAllowThreads(__tstate);
16398 if (PyErr_Occurred()) SWIG_fail;
16399 }
16400 {
16401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16402 }
16403 {
16404 if (temp2)
16405 delete arg2;
16406 }
16407 return resultobj;
16408 fail:
16409 {
16410 if (temp2)
16411 delete arg2;
16412 }
16413 return NULL;
16414 }
16415
16416
16417 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16418 PyObject *resultobj = 0;
16419 wxImage *arg1 = (wxImage *) 0 ;
16420 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16421 unsigned long result;
16422 void *argp1 = 0 ;
16423 int res1 = 0 ;
16424 unsigned long val2 ;
16425 int ecode2 = 0 ;
16426 PyObject * obj0 = 0 ;
16427 PyObject * obj1 = 0 ;
16428 char * kwnames[] = {
16429 (char *) "self",(char *) "stopafter", NULL
16430 };
16431
16432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16434 if (!SWIG_IsOK(res1)) {
16435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16436 }
16437 arg1 = reinterpret_cast< wxImage * >(argp1);
16438 if (obj1) {
16439 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16440 if (!SWIG_IsOK(ecode2)) {
16441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16442 }
16443 arg2 = static_cast< unsigned long >(val2);
16444 }
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 result = (unsigned long)(arg1)->CountColours(arg2);
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16452 return resultobj;
16453 fail:
16454 return NULL;
16455 }
16456
16457
16458 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16459 PyObject *resultobj = 0;
16460 wxImage *arg1 = (wxImage *) 0 ;
16461 wxImageHistogram *arg2 = 0 ;
16462 unsigned long result;
16463 void *argp1 = 0 ;
16464 int res1 = 0 ;
16465 void *argp2 = 0 ;
16466 int res2 = 0 ;
16467 PyObject * obj0 = 0 ;
16468 PyObject * obj1 = 0 ;
16469 char * kwnames[] = {
16470 (char *) "self",(char *) "h", NULL
16471 };
16472
16473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16475 if (!SWIG_IsOK(res1)) {
16476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16477 }
16478 arg1 = reinterpret_cast< wxImage * >(argp1);
16479 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16480 if (!SWIG_IsOK(res2)) {
16481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16482 }
16483 if (!argp2) {
16484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16485 }
16486 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16487 {
16488 PyThreadState* __tstate = wxPyBeginAllowThreads();
16489 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16490 wxPyEndAllowThreads(__tstate);
16491 if (PyErr_Occurred()) SWIG_fail;
16492 }
16493 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16494 return resultobj;
16495 fail:
16496 return NULL;
16497 }
16498
16499
16500 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16501 PyObject *resultobj = 0;
16502 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16503 void *argp1 = 0 ;
16504 int res1 = 0 ;
16505 PyObject * obj0 = 0 ;
16506 char * kwnames[] = {
16507 (char *) "handler", NULL
16508 };
16509
16510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16512 if (!SWIG_IsOK(res1)) {
16513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16514 }
16515 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16516 {
16517 PyThreadState* __tstate = wxPyBeginAllowThreads();
16518 wxImage::AddHandler(arg1);
16519 wxPyEndAllowThreads(__tstate);
16520 if (PyErr_Occurred()) SWIG_fail;
16521 }
16522 resultobj = SWIG_Py_Void();
16523 return resultobj;
16524 fail:
16525 return NULL;
16526 }
16527
16528
16529 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16530 PyObject *resultobj = 0;
16531 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16532 void *argp1 = 0 ;
16533 int res1 = 0 ;
16534 PyObject * obj0 = 0 ;
16535 char * kwnames[] = {
16536 (char *) "handler", NULL
16537 };
16538
16539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16541 if (!SWIG_IsOK(res1)) {
16542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16543 }
16544 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16545 {
16546 PyThreadState* __tstate = wxPyBeginAllowThreads();
16547 wxImage::InsertHandler(arg1);
16548 wxPyEndAllowThreads(__tstate);
16549 if (PyErr_Occurred()) SWIG_fail;
16550 }
16551 resultobj = SWIG_Py_Void();
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxString *arg1 = 0 ;
16561 bool result;
16562 bool temp1 = false ;
16563 PyObject * obj0 = 0 ;
16564 char * kwnames[] = {
16565 (char *) "name", NULL
16566 };
16567
16568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16569 {
16570 arg1 = wxString_in_helper(obj0);
16571 if (arg1 == NULL) SWIG_fail;
16572 temp1 = true;
16573 }
16574 {
16575 PyThreadState* __tstate = wxPyBeginAllowThreads();
16576 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16577 wxPyEndAllowThreads(__tstate);
16578 if (PyErr_Occurred()) SWIG_fail;
16579 }
16580 {
16581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16582 }
16583 {
16584 if (temp1)
16585 delete arg1;
16586 }
16587 return resultobj;
16588 fail:
16589 {
16590 if (temp1)
16591 delete arg1;
16592 }
16593 return NULL;
16594 }
16595
16596
16597 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16598 PyObject *resultobj = 0;
16599 PyObject *result = 0 ;
16600
16601 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = (PyObject *)wxImage_GetHandlers();
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 resultobj = result;
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16616 PyObject *resultobj = 0;
16617 wxString result;
16618
16619 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16620 {
16621 PyThreadState* __tstate = wxPyBeginAllowThreads();
16622 result = wxImage::GetImageExtWildcard();
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 {
16627 #if wxUSE_UNICODE
16628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16629 #else
16630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16631 #endif
16632 }
16633 return resultobj;
16634 fail:
16635 return NULL;
16636 }
16637
16638
16639 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16640 PyObject *resultobj = 0;
16641 wxImage *arg1 = (wxImage *) 0 ;
16642 int arg2 = (int) -1 ;
16643 wxBitmap result;
16644 void *argp1 = 0 ;
16645 int res1 = 0 ;
16646 int val2 ;
16647 int ecode2 = 0 ;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 char * kwnames[] = {
16651 (char *) "self",(char *) "depth", NULL
16652 };
16653
16654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16658 }
16659 arg1 = reinterpret_cast< wxImage * >(argp1);
16660 if (obj1) {
16661 ecode2 = SWIG_AsVal_int(obj1, &val2);
16662 if (!SWIG_IsOK(ecode2)) {
16663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16664 }
16665 arg2 = static_cast< int >(val2);
16666 }
16667 {
16668 if (!wxPyCheckForApp()) SWIG_fail;
16669 PyThreadState* __tstate = wxPyBeginAllowThreads();
16670 result = wxImage_ConvertToBitmap(arg1,arg2);
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16682 PyObject *resultobj = 0;
16683 wxImage *arg1 = (wxImage *) 0 ;
16684 byte arg2 ;
16685 byte arg3 ;
16686 byte arg4 ;
16687 wxBitmap result;
16688 void *argp1 = 0 ;
16689 int res1 = 0 ;
16690 unsigned char val2 ;
16691 int ecode2 = 0 ;
16692 unsigned char val3 ;
16693 int ecode3 = 0 ;
16694 unsigned char val4 ;
16695 int ecode4 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 PyObject * obj3 = 0 ;
16700 char * kwnames[] = {
16701 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16702 };
16703
16704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16706 if (!SWIG_IsOK(res1)) {
16707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16708 }
16709 arg1 = reinterpret_cast< wxImage * >(argp1);
16710 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16711 if (!SWIG_IsOK(ecode2)) {
16712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16713 }
16714 arg2 = static_cast< byte >(val2);
16715 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16716 if (!SWIG_IsOK(ecode3)) {
16717 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16718 }
16719 arg3 = static_cast< byte >(val3);
16720 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16721 if (!SWIG_IsOK(ecode4)) {
16722 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16723 }
16724 arg4 = static_cast< byte >(val4);
16725 {
16726 if (!wxPyCheckForApp()) SWIG_fail;
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16733 return resultobj;
16734 fail:
16735 return NULL;
16736 }
16737
16738
16739 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16740 PyObject *resultobj = 0;
16741 wxImage *arg1 = (wxImage *) 0 ;
16742 double arg2 ;
16743 void *argp1 = 0 ;
16744 int res1 = 0 ;
16745 double val2 ;
16746 int ecode2 = 0 ;
16747 PyObject * obj0 = 0 ;
16748 PyObject * obj1 = 0 ;
16749 char * kwnames[] = {
16750 (char *) "self",(char *) "angle", NULL
16751 };
16752
16753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16755 if (!SWIG_IsOK(res1)) {
16756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16757 }
16758 arg1 = reinterpret_cast< wxImage * >(argp1);
16759 ecode2 = SWIG_AsVal_double(obj1, &val2);
16760 if (!SWIG_IsOK(ecode2)) {
16761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16762 }
16763 arg2 = static_cast< double >(val2);
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 (arg1)->RotateHue(arg2);
16767 wxPyEndAllowThreads(__tstate);
16768 if (PyErr_Occurred()) SWIG_fail;
16769 }
16770 resultobj = SWIG_Py_Void();
16771 return resultobj;
16772 fail:
16773 return NULL;
16774 }
16775
16776
16777 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16778 PyObject *resultobj = 0;
16779 wxImage_RGBValue arg1 ;
16780 wxImage_HSVValue result;
16781 void *argp1 ;
16782 int res1 = 0 ;
16783 PyObject * obj0 = 0 ;
16784 char * kwnames[] = {
16785 (char *) "rgb", NULL
16786 };
16787
16788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16789 {
16790 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16793 }
16794 if (!argp1) {
16795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16796 } else {
16797 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16798 arg1 = *temp;
16799 if (SWIG_IsNewObj(res1)) delete temp;
16800 }
16801 }
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = wxImage::RGBtoHSV(arg1);
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj = 0;
16817 wxImage_HSVValue arg1 ;
16818 wxImage_RGBValue result;
16819 void *argp1 ;
16820 int res1 = 0 ;
16821 PyObject * obj0 = 0 ;
16822 char * kwnames[] = {
16823 (char *) "hsv", NULL
16824 };
16825
16826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16827 {
16828 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16829 if (!SWIG_IsOK(res1)) {
16830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16831 }
16832 if (!argp1) {
16833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16834 } else {
16835 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16836 arg1 = *temp;
16837 if (SWIG_IsNewObj(res1)) delete temp;
16838 }
16839 }
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = wxImage::HSVtoRGB(arg1);
16843 wxPyEndAllowThreads(__tstate);
16844 if (PyErr_Occurred()) SWIG_fail;
16845 }
16846 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16847 return resultobj;
16848 fail:
16849 return NULL;
16850 }
16851
16852
16853 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16854 PyObject *obj;
16855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16856 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16857 return SWIG_Py_Void();
16858 }
16859
16860 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16861 return SWIG_Python_InitShadowInstance(args);
16862 }
16863
16864 SWIGINTERN int NullImage_set(PyObject *) {
16865 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16866 return 1;
16867 }
16868
16869
16870 SWIGINTERN PyObject *NullImage_get(void) {
16871 PyObject *pyobj = 0;
16872
16873 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16874 return pyobj;
16875 }
16876
16877
16878 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16879 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16880 return 1;
16881 }
16882
16883
16884 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16885 PyObject *pyobj = 0;
16886
16887 {
16888 #if wxUSE_UNICODE
16889 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16890 #else
16891 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16892 #endif
16893 }
16894 return pyobj;
16895 }
16896
16897
16898 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16899 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16900 return 1;
16901 }
16902
16903
16904 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16905 PyObject *pyobj = 0;
16906
16907 {
16908 #if wxUSE_UNICODE
16909 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16910 #else
16911 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16912 #endif
16913 }
16914 return pyobj;
16915 }
16916
16917
16918 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16919 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16920 return 1;
16921 }
16922
16923
16924 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16925 PyObject *pyobj = 0;
16926
16927 {
16928 #if wxUSE_UNICODE
16929 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16930 #else
16931 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16932 #endif
16933 }
16934 return pyobj;
16935 }
16936
16937
16938 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16939 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16940 return 1;
16941 }
16942
16943
16944 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16945 PyObject *pyobj = 0;
16946
16947 {
16948 #if wxUSE_UNICODE
16949 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16950 #else
16951 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16952 #endif
16953 }
16954 return pyobj;
16955 }
16956
16957
16958 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16959 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16960 return 1;
16961 }
16962
16963
16964 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16965 PyObject *pyobj = 0;
16966
16967 {
16968 #if wxUSE_UNICODE
16969 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16970 #else
16971 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16972 #endif
16973 }
16974 return pyobj;
16975 }
16976
16977
16978 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16979 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16980 return 1;
16981 }
16982
16983
16984 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16985 PyObject *pyobj = 0;
16986
16987 {
16988 #if wxUSE_UNICODE
16989 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16990 #else
16991 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16992 #endif
16993 }
16994 return pyobj;
16995 }
16996
16997
16998 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16999 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17000 return 1;
17001 }
17002
17003
17004 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17005 PyObject *pyobj = 0;
17006
17007 {
17008 #if wxUSE_UNICODE
17009 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17010 #else
17011 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17012 #endif
17013 }
17014 return pyobj;
17015 }
17016
17017
17018 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17019 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17020 return 1;
17021 }
17022
17023
17024 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17025 PyObject *pyobj = 0;
17026
17027 {
17028 #if wxUSE_UNICODE
17029 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17030 #else
17031 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17032 #endif
17033 }
17034 return pyobj;
17035 }
17036
17037
17038 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17039 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17040 return 1;
17041 }
17042
17043
17044 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17045 PyObject *pyobj = 0;
17046
17047 {
17048 #if wxUSE_UNICODE
17049 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17050 #else
17051 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17052 #endif
17053 }
17054 return pyobj;
17055 }
17056
17057
17058 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17059 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17060 return 1;
17061 }
17062
17063
17064 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17065 PyObject *pyobj = 0;
17066
17067 {
17068 #if wxUSE_UNICODE
17069 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17070 #else
17071 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17072 #endif
17073 }
17074 return pyobj;
17075 }
17076
17077
17078 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17079 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17080 return 1;
17081 }
17082
17083
17084 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17085 PyObject *pyobj = 0;
17086
17087 {
17088 #if wxUSE_UNICODE
17089 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17090 #else
17091 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17092 #endif
17093 }
17094 return pyobj;
17095 }
17096
17097
17098 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17099 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17100 return 1;
17101 }
17102
17103
17104 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17105 PyObject *pyobj = 0;
17106
17107 {
17108 #if wxUSE_UNICODE
17109 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17110 #else
17111 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17112 #endif
17113 }
17114 return pyobj;
17115 }
17116
17117
17118 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17119 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17120 return 1;
17121 }
17122
17123
17124 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17125 PyObject *pyobj = 0;
17126
17127 {
17128 #if wxUSE_UNICODE
17129 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17130 #else
17131 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17132 #endif
17133 }
17134 return pyobj;
17135 }
17136
17137
17138 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17139 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17140 return 1;
17141 }
17142
17143
17144 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17145 PyObject *pyobj = 0;
17146
17147 {
17148 #if wxUSE_UNICODE
17149 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17150 #else
17151 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17152 #endif
17153 }
17154 return pyobj;
17155 }
17156
17157
17158 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17159 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17160 return 1;
17161 }
17162
17163
17164 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17165 PyObject *pyobj = 0;
17166
17167 {
17168 #if wxUSE_UNICODE
17169 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17170 #else
17171 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17172 #endif
17173 }
17174 return pyobj;
17175 }
17176
17177
17178 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17179 PyObject *resultobj = 0;
17180 wxBMPHandler *result = 0 ;
17181
17182 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (wxBMPHandler *)new wxBMPHandler();
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17197 PyObject *obj;
17198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17199 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17200 return SWIG_Py_Void();
17201 }
17202
17203 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17204 return SWIG_Python_InitShadowInstance(args);
17205 }
17206
17207 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17208 PyObject *resultobj = 0;
17209 wxICOHandler *result = 0 ;
17210
17211 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17212 {
17213 PyThreadState* __tstate = wxPyBeginAllowThreads();
17214 result = (wxICOHandler *)new wxICOHandler();
17215 wxPyEndAllowThreads(__tstate);
17216 if (PyErr_Occurred()) SWIG_fail;
17217 }
17218 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17226 PyObject *obj;
17227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17228 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17229 return SWIG_Py_Void();
17230 }
17231
17232 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17233 return SWIG_Python_InitShadowInstance(args);
17234 }
17235
17236 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17237 PyObject *resultobj = 0;
17238 wxCURHandler *result = 0 ;
17239
17240 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (wxCURHandler *)new wxCURHandler();
17244 wxPyEndAllowThreads(__tstate);
17245 if (PyErr_Occurred()) SWIG_fail;
17246 }
17247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17248 return resultobj;
17249 fail:
17250 return NULL;
17251 }
17252
17253
17254 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17255 PyObject *obj;
17256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17257 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17258 return SWIG_Py_Void();
17259 }
17260
17261 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17262 return SWIG_Python_InitShadowInstance(args);
17263 }
17264
17265 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17266 PyObject *resultobj = 0;
17267 wxANIHandler *result = 0 ;
17268
17269 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (wxANIHandler *)new wxANIHandler();
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17284 PyObject *obj;
17285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17286 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17287 return SWIG_Py_Void();
17288 }
17289
17290 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17291 return SWIG_Python_InitShadowInstance(args);
17292 }
17293
17294 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17295 PyObject *resultobj = 0;
17296 wxPNGHandler *result = 0 ;
17297
17298 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17299 {
17300 PyThreadState* __tstate = wxPyBeginAllowThreads();
17301 result = (wxPNGHandler *)new wxPNGHandler();
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17306 return resultobj;
17307 fail:
17308 return NULL;
17309 }
17310
17311
17312 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17313 PyObject *obj;
17314 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17315 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17316 return SWIG_Py_Void();
17317 }
17318
17319 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17320 return SWIG_Python_InitShadowInstance(args);
17321 }
17322
17323 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17324 PyObject *resultobj = 0;
17325 wxGIFHandler *result = 0 ;
17326
17327 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = (wxGIFHandler *)new wxGIFHandler();
17331 wxPyEndAllowThreads(__tstate);
17332 if (PyErr_Occurred()) SWIG_fail;
17333 }
17334 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17342 PyObject *obj;
17343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17344 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17345 return SWIG_Py_Void();
17346 }
17347
17348 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17349 return SWIG_Python_InitShadowInstance(args);
17350 }
17351
17352 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17353 PyObject *resultobj = 0;
17354 wxPCXHandler *result = 0 ;
17355
17356 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (wxPCXHandler *)new wxPCXHandler();
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17364 return resultobj;
17365 fail:
17366 return NULL;
17367 }
17368
17369
17370 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17371 PyObject *obj;
17372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17373 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17374 return SWIG_Py_Void();
17375 }
17376
17377 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17378 return SWIG_Python_InitShadowInstance(args);
17379 }
17380
17381 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17382 PyObject *resultobj = 0;
17383 wxJPEGHandler *result = 0 ;
17384
17385 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17386 {
17387 PyThreadState* __tstate = wxPyBeginAllowThreads();
17388 result = (wxJPEGHandler *)new wxJPEGHandler();
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17393 return resultobj;
17394 fail:
17395 return NULL;
17396 }
17397
17398
17399 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17400 PyObject *obj;
17401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17402 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17403 return SWIG_Py_Void();
17404 }
17405
17406 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17407 return SWIG_Python_InitShadowInstance(args);
17408 }
17409
17410 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17411 PyObject *resultobj = 0;
17412 wxPNMHandler *result = 0 ;
17413
17414 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (wxPNMHandler *)new wxPNMHandler();
17418 wxPyEndAllowThreads(__tstate);
17419 if (PyErr_Occurred()) SWIG_fail;
17420 }
17421 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17422 return resultobj;
17423 fail:
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17429 PyObject *obj;
17430 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17431 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17432 return SWIG_Py_Void();
17433 }
17434
17435 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17436 return SWIG_Python_InitShadowInstance(args);
17437 }
17438
17439 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 PyObject *resultobj = 0;
17441 wxXPMHandler *result = 0 ;
17442
17443 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (wxXPMHandler *)new wxXPMHandler();
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 PyObject *obj;
17459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17460 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17461 return SWIG_Py_Void();
17462 }
17463
17464 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17465 return SWIG_Python_InitShadowInstance(args);
17466 }
17467
17468 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 PyObject *resultobj = 0;
17470 wxTIFFHandler *result = 0 ;
17471
17472 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17473 {
17474 PyThreadState* __tstate = wxPyBeginAllowThreads();
17475 result = (wxTIFFHandler *)new wxTIFFHandler();
17476 wxPyEndAllowThreads(__tstate);
17477 if (PyErr_Occurred()) SWIG_fail;
17478 }
17479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17480 return resultobj;
17481 fail:
17482 return NULL;
17483 }
17484
17485
17486 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17487 PyObject *obj;
17488 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17489 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17490 return SWIG_Py_Void();
17491 }
17492
17493 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17494 return SWIG_Python_InitShadowInstance(args);
17495 }
17496
17497 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17498 PyObject *resultobj = 0;
17499 wxImage *arg1 = 0 ;
17500 wxImage *arg2 = 0 ;
17501 int arg3 = (int) 236 ;
17502 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17503 bool result;
17504 void *argp1 = 0 ;
17505 int res1 = 0 ;
17506 void *argp2 = 0 ;
17507 int res2 = 0 ;
17508 int val3 ;
17509 int ecode3 = 0 ;
17510 int val4 ;
17511 int ecode4 = 0 ;
17512 PyObject * obj0 = 0 ;
17513 PyObject * obj1 = 0 ;
17514 PyObject * obj2 = 0 ;
17515 PyObject * obj3 = 0 ;
17516 char * kwnames[] = {
17517 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17518 };
17519
17520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17521 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17522 if (!SWIG_IsOK(res1)) {
17523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17524 }
17525 if (!argp1) {
17526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17527 }
17528 arg1 = reinterpret_cast< wxImage * >(argp1);
17529 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17530 if (!SWIG_IsOK(res2)) {
17531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17532 }
17533 if (!argp2) {
17534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17535 }
17536 arg2 = reinterpret_cast< wxImage * >(argp2);
17537 if (obj2) {
17538 ecode3 = SWIG_AsVal_int(obj2, &val3);
17539 if (!SWIG_IsOK(ecode3)) {
17540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17541 }
17542 arg3 = static_cast< int >(val3);
17543 }
17544 if (obj3) {
17545 ecode4 = SWIG_AsVal_int(obj3, &val4);
17546 if (!SWIG_IsOK(ecode4)) {
17547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17548 }
17549 arg4 = static_cast< int >(val4);
17550 }
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 {
17558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17559 }
17560 return resultobj;
17561 fail:
17562 return NULL;
17563 }
17564
17565
17566 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17567 PyObject *obj;
17568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17569 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17570 return SWIG_Py_Void();
17571 }
17572
17573 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17574 PyObject *resultobj = 0;
17575 wxEvtHandler *result = 0 ;
17576
17577 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = (wxEvtHandler *)new wxEvtHandler();
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *resultobj = 0;
17593 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17594 wxEvtHandler *result = 0 ;
17595 void *argp1 = 0 ;
17596 int res1 = 0 ;
17597 PyObject *swig_obj[1] ;
17598
17599 if (!args) SWIG_fail;
17600 swig_obj[0] = args;
17601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17602 if (!SWIG_IsOK(res1)) {
17603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17604 }
17605 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17606 {
17607 PyThreadState* __tstate = wxPyBeginAllowThreads();
17608 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = wxPyMake_wxObject(result, 0);
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17622 PyObject *resultobj = 0;
17623 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17624 wxEvtHandler *result = 0 ;
17625 void *argp1 = 0 ;
17626 int res1 = 0 ;
17627 PyObject *swig_obj[1] ;
17628
17629 if (!args) SWIG_fail;
17630 swig_obj[0] = args;
17631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17632 if (!SWIG_IsOK(res1)) {
17633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17634 }
17635 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17636 {
17637 PyThreadState* __tstate = wxPyBeginAllowThreads();
17638 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 {
17643 resultobj = wxPyMake_wxObject(result, 0);
17644 }
17645 return resultobj;
17646 fail:
17647 return NULL;
17648 }
17649
17650
17651 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17652 PyObject *resultobj = 0;
17653 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17654 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17655 void *argp1 = 0 ;
17656 int res1 = 0 ;
17657 void *argp2 = 0 ;
17658 int res2 = 0 ;
17659 PyObject * obj0 = 0 ;
17660 PyObject * obj1 = 0 ;
17661 char * kwnames[] = {
17662 (char *) "self",(char *) "handler", NULL
17663 };
17664
17665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17667 if (!SWIG_IsOK(res1)) {
17668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17669 }
17670 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17672 if (!SWIG_IsOK(res2)) {
17673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17674 }
17675 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 (arg1)->SetNextHandler(arg2);
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 resultobj = SWIG_Py_Void();
17683 return resultobj;
17684 fail:
17685 return NULL;
17686 }
17687
17688
17689 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17690 PyObject *resultobj = 0;
17691 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17692 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 void *argp2 = 0 ;
17696 int res2 = 0 ;
17697 PyObject * obj0 = 0 ;
17698 PyObject * obj1 = 0 ;
17699 char * kwnames[] = {
17700 (char *) "self",(char *) "handler", NULL
17701 };
17702
17703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17705 if (!SWIG_IsOK(res1)) {
17706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17707 }
17708 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17710 if (!SWIG_IsOK(res2)) {
17711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17712 }
17713 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17714 {
17715 PyThreadState* __tstate = wxPyBeginAllowThreads();
17716 (arg1)->SetPreviousHandler(arg2);
17717 wxPyEndAllowThreads(__tstate);
17718 if (PyErr_Occurred()) SWIG_fail;
17719 }
17720 resultobj = SWIG_Py_Void();
17721 return resultobj;
17722 fail:
17723 return NULL;
17724 }
17725
17726
17727 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17728 PyObject *resultobj = 0;
17729 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17730 bool result;
17731 void *argp1 = 0 ;
17732 int res1 = 0 ;
17733 PyObject *swig_obj[1] ;
17734
17735 if (!args) SWIG_fail;
17736 swig_obj[0] = args;
17737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17738 if (!SWIG_IsOK(res1)) {
17739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17740 }
17741 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17742 {
17743 PyThreadState* __tstate = wxPyBeginAllowThreads();
17744 result = (bool)(arg1)->GetEvtHandlerEnabled();
17745 wxPyEndAllowThreads(__tstate);
17746 if (PyErr_Occurred()) SWIG_fail;
17747 }
17748 {
17749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17750 }
17751 return resultobj;
17752 fail:
17753 return NULL;
17754 }
17755
17756
17757 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj = 0;
17759 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17760 bool arg2 ;
17761 void *argp1 = 0 ;
17762 int res1 = 0 ;
17763 bool val2 ;
17764 int ecode2 = 0 ;
17765 PyObject * obj0 = 0 ;
17766 PyObject * obj1 = 0 ;
17767 char * kwnames[] = {
17768 (char *) "self",(char *) "enabled", NULL
17769 };
17770
17771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17773 if (!SWIG_IsOK(res1)) {
17774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17775 }
17776 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17777 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17778 if (!SWIG_IsOK(ecode2)) {
17779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17780 }
17781 arg2 = static_cast< bool >(val2);
17782 {
17783 PyThreadState* __tstate = wxPyBeginAllowThreads();
17784 (arg1)->SetEvtHandlerEnabled(arg2);
17785 wxPyEndAllowThreads(__tstate);
17786 if (PyErr_Occurred()) SWIG_fail;
17787 }
17788 resultobj = SWIG_Py_Void();
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj = 0;
17797 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17798 wxEvent *arg2 = 0 ;
17799 bool result;
17800 void *argp1 = 0 ;
17801 int res1 = 0 ;
17802 void *argp2 = 0 ;
17803 int res2 = 0 ;
17804 PyObject * obj0 = 0 ;
17805 PyObject * obj1 = 0 ;
17806 char * kwnames[] = {
17807 (char *) "self",(char *) "event", NULL
17808 };
17809
17810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17812 if (!SWIG_IsOK(res1)) {
17813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17814 }
17815 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17816 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17817 if (!SWIG_IsOK(res2)) {
17818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17819 }
17820 if (!argp2) {
17821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17822 }
17823 arg2 = reinterpret_cast< wxEvent * >(argp2);
17824 {
17825 PyThreadState* __tstate = wxPyBeginAllowThreads();
17826 result = (bool)(arg1)->ProcessEvent(*arg2);
17827 wxPyEndAllowThreads(__tstate);
17828 if (PyErr_Occurred()) SWIG_fail;
17829 }
17830 {
17831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17832 }
17833 return resultobj;
17834 fail:
17835 return NULL;
17836 }
17837
17838
17839 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17840 PyObject *resultobj = 0;
17841 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17842 wxEvent *arg2 = 0 ;
17843 void *argp1 = 0 ;
17844 int res1 = 0 ;
17845 void *argp2 = 0 ;
17846 int res2 = 0 ;
17847 PyObject * obj0 = 0 ;
17848 PyObject * obj1 = 0 ;
17849 char * kwnames[] = {
17850 (char *) "self",(char *) "event", NULL
17851 };
17852
17853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17855 if (!SWIG_IsOK(res1)) {
17856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17857 }
17858 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17859 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17860 if (!SWIG_IsOK(res2)) {
17861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17862 }
17863 if (!argp2) {
17864 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17865 }
17866 arg2 = reinterpret_cast< wxEvent * >(argp2);
17867 {
17868 PyThreadState* __tstate = wxPyBeginAllowThreads();
17869 (arg1)->AddPendingEvent(*arg2);
17870 wxPyEndAllowThreads(__tstate);
17871 if (PyErr_Occurred()) SWIG_fail;
17872 }
17873 resultobj = SWIG_Py_Void();
17874 return resultobj;
17875 fail:
17876 return NULL;
17877 }
17878
17879
17880 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17881 PyObject *resultobj = 0;
17882 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17883 void *argp1 = 0 ;
17884 int res1 = 0 ;
17885 PyObject *swig_obj[1] ;
17886
17887 if (!args) SWIG_fail;
17888 swig_obj[0] = args;
17889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17890 if (!SWIG_IsOK(res1)) {
17891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17892 }
17893 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17894 {
17895 PyThreadState* __tstate = wxPyBeginAllowThreads();
17896 (arg1)->ProcessPendingEvents();
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 resultobj = SWIG_Py_Void();
17901 return resultobj;
17902 fail:
17903 return NULL;
17904 }
17905
17906
17907 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17908 PyObject *resultobj = 0;
17909 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17910 int arg2 ;
17911 int arg3 ;
17912 int arg4 ;
17913 PyObject *arg5 = (PyObject *) 0 ;
17914 void *argp1 = 0 ;
17915 int res1 = 0 ;
17916 int val2 ;
17917 int ecode2 = 0 ;
17918 int val3 ;
17919 int ecode3 = 0 ;
17920 int val4 ;
17921 int ecode4 = 0 ;
17922 PyObject * obj0 = 0 ;
17923 PyObject * obj1 = 0 ;
17924 PyObject * obj2 = 0 ;
17925 PyObject * obj3 = 0 ;
17926 PyObject * obj4 = 0 ;
17927 char * kwnames[] = {
17928 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17929 };
17930
17931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17933 if (!SWIG_IsOK(res1)) {
17934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17935 }
17936 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17937 ecode2 = SWIG_AsVal_int(obj1, &val2);
17938 if (!SWIG_IsOK(ecode2)) {
17939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17940 }
17941 arg2 = static_cast< int >(val2);
17942 ecode3 = SWIG_AsVal_int(obj2, &val3);
17943 if (!SWIG_IsOK(ecode3)) {
17944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17945 }
17946 arg3 = static_cast< int >(val3);
17947 ecode4 = SWIG_AsVal_int(obj3, &val4);
17948 if (!SWIG_IsOK(ecode4)) {
17949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17950 }
17951 arg4 = static_cast< int >(val4);
17952 arg5 = obj4;
17953 {
17954 PyThreadState* __tstate = wxPyBeginAllowThreads();
17955 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17956 wxPyEndAllowThreads(__tstate);
17957 if (PyErr_Occurred()) SWIG_fail;
17958 }
17959 resultobj = SWIG_Py_Void();
17960 return resultobj;
17961 fail:
17962 return NULL;
17963 }
17964
17965
17966 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17967 PyObject *resultobj = 0;
17968 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17969 int arg2 ;
17970 int arg3 = (int) -1 ;
17971 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17972 bool result;
17973 void *argp1 = 0 ;
17974 int res1 = 0 ;
17975 int val2 ;
17976 int ecode2 = 0 ;
17977 int val3 ;
17978 int ecode3 = 0 ;
17979 int val4 ;
17980 int ecode4 = 0 ;
17981 PyObject * obj0 = 0 ;
17982 PyObject * obj1 = 0 ;
17983 PyObject * obj2 = 0 ;
17984 PyObject * obj3 = 0 ;
17985 char * kwnames[] = {
17986 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17987 };
17988
17989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17991 if (!SWIG_IsOK(res1)) {
17992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17993 }
17994 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17995 ecode2 = SWIG_AsVal_int(obj1, &val2);
17996 if (!SWIG_IsOK(ecode2)) {
17997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17998 }
17999 arg2 = static_cast< int >(val2);
18000 if (obj2) {
18001 ecode3 = SWIG_AsVal_int(obj2, &val3);
18002 if (!SWIG_IsOK(ecode3)) {
18003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18004 }
18005 arg3 = static_cast< int >(val3);
18006 }
18007 if (obj3) {
18008 ecode4 = SWIG_AsVal_int(obj3, &val4);
18009 if (!SWIG_IsOK(ecode4)) {
18010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18011 }
18012 arg4 = static_cast< wxEventType >(val4);
18013 }
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18017 wxPyEndAllowThreads(__tstate);
18018 if (PyErr_Occurred()) SWIG_fail;
18019 }
18020 {
18021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18022 }
18023 return resultobj;
18024 fail:
18025 return NULL;
18026 }
18027
18028
18029 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj = 0;
18031 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18032 PyObject *arg2 = (PyObject *) 0 ;
18033 bool arg3 = (bool) true ;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 bool val3 ;
18037 int ecode3 = 0 ;
18038 PyObject * obj0 = 0 ;
18039 PyObject * obj1 = 0 ;
18040 PyObject * obj2 = 0 ;
18041 char * kwnames[] = {
18042 (char *) "self",(char *) "_self",(char *) "incref", NULL
18043 };
18044
18045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18049 }
18050 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18051 arg2 = obj1;
18052 if (obj2) {
18053 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18054 if (!SWIG_IsOK(ecode3)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18056 }
18057 arg3 = static_cast< bool >(val3);
18058 }
18059 {
18060 PyThreadState* __tstate = wxPyBeginAllowThreads();
18061 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 resultobj = SWIG_Py_Void();
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18073 PyObject *obj;
18074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18075 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18076 return SWIG_Py_Void();
18077 }
18078
18079 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18080 return SWIG_Python_InitShadowInstance(args);
18081 }
18082
18083 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18084 PyObject *resultobj = 0;
18085 wxEventType result;
18086
18087 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18088 {
18089 PyThreadState* __tstate = wxPyBeginAllowThreads();
18090 result = (wxEventType)wxNewEventType();
18091 wxPyEndAllowThreads(__tstate);
18092 if (PyErr_Occurred()) SWIG_fail;
18093 }
18094 resultobj = SWIG_From_int(static_cast< int >(result));
18095 return resultobj;
18096 fail:
18097 return NULL;
18098 }
18099
18100
18101 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18102 PyObject *resultobj = 0;
18103 wxEvent *arg1 = (wxEvent *) 0 ;
18104 void *argp1 = 0 ;
18105 int res1 = 0 ;
18106 PyObject *swig_obj[1] ;
18107
18108 if (!args) SWIG_fail;
18109 swig_obj[0] = args;
18110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18113 }
18114 arg1 = reinterpret_cast< wxEvent * >(argp1);
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 delete arg1;
18118
18119 wxPyEndAllowThreads(__tstate);
18120 if (PyErr_Occurred()) SWIG_fail;
18121 }
18122 resultobj = SWIG_Py_Void();
18123 return resultobj;
18124 fail:
18125 return NULL;
18126 }
18127
18128
18129 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18130 PyObject *resultobj = 0;
18131 wxEvent *arg1 = (wxEvent *) 0 ;
18132 wxEventType arg2 ;
18133 void *argp1 = 0 ;
18134 int res1 = 0 ;
18135 int val2 ;
18136 int ecode2 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 char * kwnames[] = {
18140 (char *) "self",(char *) "typ", NULL
18141 };
18142
18143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18147 }
18148 arg1 = reinterpret_cast< wxEvent * >(argp1);
18149 ecode2 = SWIG_AsVal_int(obj1, &val2);
18150 if (!SWIG_IsOK(ecode2)) {
18151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18152 }
18153 arg2 = static_cast< wxEventType >(val2);
18154 {
18155 PyThreadState* __tstate = wxPyBeginAllowThreads();
18156 (arg1)->SetEventType(arg2);
18157 wxPyEndAllowThreads(__tstate);
18158 if (PyErr_Occurred()) SWIG_fail;
18159 }
18160 resultobj = SWIG_Py_Void();
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18168 PyObject *resultobj = 0;
18169 wxEvent *arg1 = (wxEvent *) 0 ;
18170 wxEventType result;
18171 void *argp1 = 0 ;
18172 int res1 = 0 ;
18173 PyObject *swig_obj[1] ;
18174
18175 if (!args) SWIG_fail;
18176 swig_obj[0] = args;
18177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18178 if (!SWIG_IsOK(res1)) {
18179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18180 }
18181 arg1 = reinterpret_cast< wxEvent * >(argp1);
18182 {
18183 PyThreadState* __tstate = wxPyBeginAllowThreads();
18184 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18185 wxPyEndAllowThreads(__tstate);
18186 if (PyErr_Occurred()) SWIG_fail;
18187 }
18188 resultobj = SWIG_From_int(static_cast< int >(result));
18189 return resultobj;
18190 fail:
18191 return NULL;
18192 }
18193
18194
18195 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18196 PyObject *resultobj = 0;
18197 wxEvent *arg1 = (wxEvent *) 0 ;
18198 wxObject *result = 0 ;
18199 void *argp1 = 0 ;
18200 int res1 = 0 ;
18201 PyObject *swig_obj[1] ;
18202
18203 if (!args) SWIG_fail;
18204 swig_obj[0] = args;
18205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18206 if (!SWIG_IsOK(res1)) {
18207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18208 }
18209 arg1 = reinterpret_cast< wxEvent * >(argp1);
18210 {
18211 PyThreadState* __tstate = wxPyBeginAllowThreads();
18212 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18213 wxPyEndAllowThreads(__tstate);
18214 if (PyErr_Occurred()) SWIG_fail;
18215 }
18216 {
18217 resultobj = wxPyMake_wxObject(result, (bool)0);
18218 }
18219 return resultobj;
18220 fail:
18221 return NULL;
18222 }
18223
18224
18225 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18226 PyObject *resultobj = 0;
18227 wxEvent *arg1 = (wxEvent *) 0 ;
18228 wxObject *arg2 = (wxObject *) 0 ;
18229 void *argp1 = 0 ;
18230 int res1 = 0 ;
18231 void *argp2 = 0 ;
18232 int res2 = 0 ;
18233 PyObject * obj0 = 0 ;
18234 PyObject * obj1 = 0 ;
18235 char * kwnames[] = {
18236 (char *) "self",(char *) "obj", NULL
18237 };
18238
18239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18241 if (!SWIG_IsOK(res1)) {
18242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18243 }
18244 arg1 = reinterpret_cast< wxEvent * >(argp1);
18245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18246 if (!SWIG_IsOK(res2)) {
18247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18248 }
18249 arg2 = reinterpret_cast< wxObject * >(argp2);
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 (arg1)->SetEventObject(arg2);
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 resultobj = SWIG_Py_Void();
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264 PyObject *resultobj = 0;
18265 wxEvent *arg1 = (wxEvent *) 0 ;
18266 long result;
18267 void *argp1 = 0 ;
18268 int res1 = 0 ;
18269 PyObject *swig_obj[1] ;
18270
18271 if (!args) SWIG_fail;
18272 swig_obj[0] = args;
18273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18274 if (!SWIG_IsOK(res1)) {
18275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18276 }
18277 arg1 = reinterpret_cast< wxEvent * >(argp1);
18278 {
18279 PyThreadState* __tstate = wxPyBeginAllowThreads();
18280 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18281 wxPyEndAllowThreads(__tstate);
18282 if (PyErr_Occurred()) SWIG_fail;
18283 }
18284 resultobj = SWIG_From_long(static_cast< long >(result));
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18292 PyObject *resultobj = 0;
18293 wxEvent *arg1 = (wxEvent *) 0 ;
18294 long arg2 = (long) 0 ;
18295 void *argp1 = 0 ;
18296 int res1 = 0 ;
18297 long val2 ;
18298 int ecode2 = 0 ;
18299 PyObject * obj0 = 0 ;
18300 PyObject * obj1 = 0 ;
18301 char * kwnames[] = {
18302 (char *) "self",(char *) "ts", NULL
18303 };
18304
18305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18307 if (!SWIG_IsOK(res1)) {
18308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18309 }
18310 arg1 = reinterpret_cast< wxEvent * >(argp1);
18311 if (obj1) {
18312 ecode2 = SWIG_AsVal_long(obj1, &val2);
18313 if (!SWIG_IsOK(ecode2)) {
18314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18315 }
18316 arg2 = static_cast< long >(val2);
18317 }
18318 {
18319 PyThreadState* __tstate = wxPyBeginAllowThreads();
18320 (arg1)->SetTimestamp(arg2);
18321 wxPyEndAllowThreads(__tstate);
18322 if (PyErr_Occurred()) SWIG_fail;
18323 }
18324 resultobj = SWIG_Py_Void();
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18332 PyObject *resultobj = 0;
18333 wxEvent *arg1 = (wxEvent *) 0 ;
18334 int result;
18335 void *argp1 = 0 ;
18336 int res1 = 0 ;
18337 PyObject *swig_obj[1] ;
18338
18339 if (!args) SWIG_fail;
18340 swig_obj[0] = args;
18341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18342 if (!SWIG_IsOK(res1)) {
18343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18344 }
18345 arg1 = reinterpret_cast< wxEvent * >(argp1);
18346 {
18347 PyThreadState* __tstate = wxPyBeginAllowThreads();
18348 result = (int)((wxEvent const *)arg1)->GetId();
18349 wxPyEndAllowThreads(__tstate);
18350 if (PyErr_Occurred()) SWIG_fail;
18351 }
18352 resultobj = SWIG_From_int(static_cast< int >(result));
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj = 0;
18361 wxEvent *arg1 = (wxEvent *) 0 ;
18362 int arg2 ;
18363 void *argp1 = 0 ;
18364 int res1 = 0 ;
18365 int val2 ;
18366 int ecode2 = 0 ;
18367 PyObject * obj0 = 0 ;
18368 PyObject * obj1 = 0 ;
18369 char * kwnames[] = {
18370 (char *) "self",(char *) "Id", NULL
18371 };
18372
18373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18375 if (!SWIG_IsOK(res1)) {
18376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18377 }
18378 arg1 = reinterpret_cast< wxEvent * >(argp1);
18379 ecode2 = SWIG_AsVal_int(obj1, &val2);
18380 if (!SWIG_IsOK(ecode2)) {
18381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18382 }
18383 arg2 = static_cast< int >(val2);
18384 {
18385 PyThreadState* __tstate = wxPyBeginAllowThreads();
18386 (arg1)->SetId(arg2);
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 resultobj = SWIG_Py_Void();
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18398 PyObject *resultobj = 0;
18399 wxEvent *arg1 = (wxEvent *) 0 ;
18400 bool result;
18401 void *argp1 = 0 ;
18402 int res1 = 0 ;
18403 PyObject *swig_obj[1] ;
18404
18405 if (!args) SWIG_fail;
18406 swig_obj[0] = args;
18407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18408 if (!SWIG_IsOK(res1)) {
18409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18410 }
18411 arg1 = reinterpret_cast< wxEvent * >(argp1);
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 {
18419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18420 }
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj = 0;
18429 wxEvent *arg1 = (wxEvent *) 0 ;
18430 bool arg2 = (bool) true ;
18431 void *argp1 = 0 ;
18432 int res1 = 0 ;
18433 bool val2 ;
18434 int ecode2 = 0 ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 char * kwnames[] = {
18438 (char *) "self",(char *) "skip", NULL
18439 };
18440
18441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18443 if (!SWIG_IsOK(res1)) {
18444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18445 }
18446 arg1 = reinterpret_cast< wxEvent * >(argp1);
18447 if (obj1) {
18448 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18449 if (!SWIG_IsOK(ecode2)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18451 }
18452 arg2 = static_cast< bool >(val2);
18453 }
18454 {
18455 PyThreadState* __tstate = wxPyBeginAllowThreads();
18456 (arg1)->Skip(arg2);
18457 wxPyEndAllowThreads(__tstate);
18458 if (PyErr_Occurred()) SWIG_fail;
18459 }
18460 resultobj = SWIG_Py_Void();
18461 return resultobj;
18462 fail:
18463 return NULL;
18464 }
18465
18466
18467 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18468 PyObject *resultobj = 0;
18469 wxEvent *arg1 = (wxEvent *) 0 ;
18470 bool result;
18471 void *argp1 = 0 ;
18472 int res1 = 0 ;
18473 PyObject *swig_obj[1] ;
18474
18475 if (!args) SWIG_fail;
18476 swig_obj[0] = args;
18477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18478 if (!SWIG_IsOK(res1)) {
18479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18480 }
18481 arg1 = reinterpret_cast< wxEvent * >(argp1);
18482 {
18483 PyThreadState* __tstate = wxPyBeginAllowThreads();
18484 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18485 wxPyEndAllowThreads(__tstate);
18486 if (PyErr_Occurred()) SWIG_fail;
18487 }
18488 {
18489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18490 }
18491 return resultobj;
18492 fail:
18493 return NULL;
18494 }
18495
18496
18497 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18498 PyObject *resultobj = 0;
18499 wxEvent *arg1 = (wxEvent *) 0 ;
18500 bool result;
18501 void *argp1 = 0 ;
18502 int res1 = 0 ;
18503 PyObject *swig_obj[1] ;
18504
18505 if (!args) SWIG_fail;
18506 swig_obj[0] = args;
18507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18508 if (!SWIG_IsOK(res1)) {
18509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18510 }
18511 arg1 = reinterpret_cast< wxEvent * >(argp1);
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18515 wxPyEndAllowThreads(__tstate);
18516 if (PyErr_Occurred()) SWIG_fail;
18517 }
18518 {
18519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18520 }
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18528 PyObject *resultobj = 0;
18529 wxEvent *arg1 = (wxEvent *) 0 ;
18530 int result;
18531 void *argp1 = 0 ;
18532 int res1 = 0 ;
18533 PyObject *swig_obj[1] ;
18534
18535 if (!args) SWIG_fail;
18536 swig_obj[0] = args;
18537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18538 if (!SWIG_IsOK(res1)) {
18539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18540 }
18541 arg1 = reinterpret_cast< wxEvent * >(argp1);
18542 {
18543 PyThreadState* __tstate = wxPyBeginAllowThreads();
18544 result = (int)(arg1)->StopPropagation();
18545 wxPyEndAllowThreads(__tstate);
18546 if (PyErr_Occurred()) SWIG_fail;
18547 }
18548 resultobj = SWIG_From_int(static_cast< int >(result));
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj = 0;
18557 wxEvent *arg1 = (wxEvent *) 0 ;
18558 int arg2 ;
18559 void *argp1 = 0 ;
18560 int res1 = 0 ;
18561 int val2 ;
18562 int ecode2 = 0 ;
18563 PyObject * obj0 = 0 ;
18564 PyObject * obj1 = 0 ;
18565 char * kwnames[] = {
18566 (char *) "self",(char *) "propagationLevel", NULL
18567 };
18568
18569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18571 if (!SWIG_IsOK(res1)) {
18572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18573 }
18574 arg1 = reinterpret_cast< wxEvent * >(argp1);
18575 ecode2 = SWIG_AsVal_int(obj1, &val2);
18576 if (!SWIG_IsOK(ecode2)) {
18577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18578 }
18579 arg2 = static_cast< int >(val2);
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 (arg1)->ResumePropagation(arg2);
18583 wxPyEndAllowThreads(__tstate);
18584 if (PyErr_Occurred()) SWIG_fail;
18585 }
18586 resultobj = SWIG_Py_Void();
18587 return resultobj;
18588 fail:
18589 return NULL;
18590 }
18591
18592
18593 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18594 PyObject *resultobj = 0;
18595 wxEvent *arg1 = (wxEvent *) 0 ;
18596 wxEvent *result = 0 ;
18597 void *argp1 = 0 ;
18598 int res1 = 0 ;
18599 PyObject *swig_obj[1] ;
18600
18601 if (!args) SWIG_fail;
18602 swig_obj[0] = args;
18603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18604 if (!SWIG_IsOK(res1)) {
18605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18606 }
18607 arg1 = reinterpret_cast< wxEvent * >(argp1);
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 result = (wxEvent *)(arg1)->Clone();
18611 wxPyEndAllowThreads(__tstate);
18612 if (PyErr_Occurred()) SWIG_fail;
18613 }
18614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18615 return resultobj;
18616 fail:
18617 return NULL;
18618 }
18619
18620
18621 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18622 PyObject *obj;
18623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18624 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18625 return SWIG_Py_Void();
18626 }
18627
18628 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18629 PyObject *resultobj = 0;
18630 wxEvent *arg1 = 0 ;
18631 wxPropagationDisabler *result = 0 ;
18632 void *argp1 = 0 ;
18633 int res1 = 0 ;
18634 PyObject * obj0 = 0 ;
18635 char * kwnames[] = {
18636 (char *) "event", NULL
18637 };
18638
18639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18640 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18641 if (!SWIG_IsOK(res1)) {
18642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18643 }
18644 if (!argp1) {
18645 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18646 }
18647 arg1 = reinterpret_cast< wxEvent * >(argp1);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 PyObject *resultobj = 0;
18663 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18664 void *argp1 = 0 ;
18665 int res1 = 0 ;
18666 PyObject *swig_obj[1] ;
18667
18668 if (!args) SWIG_fail;
18669 swig_obj[0] = args;
18670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18673 }
18674 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 delete arg1;
18678
18679 wxPyEndAllowThreads(__tstate);
18680 if (PyErr_Occurred()) SWIG_fail;
18681 }
18682 resultobj = SWIG_Py_Void();
18683 return resultobj;
18684 fail:
18685 return NULL;
18686 }
18687
18688
18689 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18690 PyObject *obj;
18691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18692 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18693 return SWIG_Py_Void();
18694 }
18695
18696 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18697 return SWIG_Python_InitShadowInstance(args);
18698 }
18699
18700 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18701 PyObject *resultobj = 0;
18702 wxEvent *arg1 = 0 ;
18703 wxPropagateOnce *result = 0 ;
18704 void *argp1 = 0 ;
18705 int res1 = 0 ;
18706 PyObject * obj0 = 0 ;
18707 char * kwnames[] = {
18708 (char *) "event", NULL
18709 };
18710
18711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18712 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18713 if (!SWIG_IsOK(res1)) {
18714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18715 }
18716 if (!argp1) {
18717 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18718 }
18719 arg1 = reinterpret_cast< wxEvent * >(argp1);
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18734 PyObject *resultobj = 0;
18735 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18736 void *argp1 = 0 ;
18737 int res1 = 0 ;
18738 PyObject *swig_obj[1] ;
18739
18740 if (!args) SWIG_fail;
18741 swig_obj[0] = args;
18742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18743 if (!SWIG_IsOK(res1)) {
18744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18745 }
18746 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 delete arg1;
18750
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 resultobj = SWIG_Py_Void();
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18762 PyObject *obj;
18763 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18764 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18765 return SWIG_Py_Void();
18766 }
18767
18768 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18769 return SWIG_Python_InitShadowInstance(args);
18770 }
18771
18772 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18773 PyObject *resultobj = 0;
18774 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18775 int arg2 = (int) 0 ;
18776 wxCommandEvent *result = 0 ;
18777 int val1 ;
18778 int ecode1 = 0 ;
18779 int val2 ;
18780 int ecode2 = 0 ;
18781 PyObject * obj0 = 0 ;
18782 PyObject * obj1 = 0 ;
18783 char * kwnames[] = {
18784 (char *) "commandType",(char *) "winid", NULL
18785 };
18786
18787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18788 if (obj0) {
18789 ecode1 = SWIG_AsVal_int(obj0, &val1);
18790 if (!SWIG_IsOK(ecode1)) {
18791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18792 }
18793 arg1 = static_cast< wxEventType >(val1);
18794 }
18795 if (obj1) {
18796 ecode2 = SWIG_AsVal_int(obj1, &val2);
18797 if (!SWIG_IsOK(ecode2)) {
18798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18799 }
18800 arg2 = static_cast< int >(val2);
18801 }
18802 {
18803 PyThreadState* __tstate = wxPyBeginAllowThreads();
18804 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18805 wxPyEndAllowThreads(__tstate);
18806 if (PyErr_Occurred()) SWIG_fail;
18807 }
18808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18816 PyObject *resultobj = 0;
18817 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18818 int result;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject *swig_obj[1] ;
18822
18823 if (!args) SWIG_fail;
18824 swig_obj[0] = args;
18825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18828 }
18829 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 resultobj = SWIG_From_int(static_cast< int >(result));
18837 return resultobj;
18838 fail:
18839 return NULL;
18840 }
18841
18842
18843 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18844 PyObject *resultobj = 0;
18845 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18846 wxString *arg2 = 0 ;
18847 void *argp1 = 0 ;
18848 int res1 = 0 ;
18849 bool temp2 = false ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char * kwnames[] = {
18853 (char *) "self",(char *) "s", NULL
18854 };
18855
18856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18860 }
18861 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18862 {
18863 arg2 = wxString_in_helper(obj1);
18864 if (arg2 == NULL) SWIG_fail;
18865 temp2 = true;
18866 }
18867 {
18868 PyThreadState* __tstate = wxPyBeginAllowThreads();
18869 (arg1)->SetString((wxString const &)*arg2);
18870 wxPyEndAllowThreads(__tstate);
18871 if (PyErr_Occurred()) SWIG_fail;
18872 }
18873 resultobj = SWIG_Py_Void();
18874 {
18875 if (temp2)
18876 delete arg2;
18877 }
18878 return resultobj;
18879 fail:
18880 {
18881 if (temp2)
18882 delete arg2;
18883 }
18884 return NULL;
18885 }
18886
18887
18888 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18889 PyObject *resultobj = 0;
18890 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18891 wxString result;
18892 void *argp1 = 0 ;
18893 int res1 = 0 ;
18894 PyObject *swig_obj[1] ;
18895
18896 if (!args) SWIG_fail;
18897 swig_obj[0] = args;
18898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18899 if (!SWIG_IsOK(res1)) {
18900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18901 }
18902 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18903 {
18904 PyThreadState* __tstate = wxPyBeginAllowThreads();
18905 result = ((wxCommandEvent const *)arg1)->GetString();
18906 wxPyEndAllowThreads(__tstate);
18907 if (PyErr_Occurred()) SWIG_fail;
18908 }
18909 {
18910 #if wxUSE_UNICODE
18911 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18912 #else
18913 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18914 #endif
18915 }
18916 return resultobj;
18917 fail:
18918 return NULL;
18919 }
18920
18921
18922 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18923 PyObject *resultobj = 0;
18924 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18925 bool result;
18926 void *argp1 = 0 ;
18927 int res1 = 0 ;
18928 PyObject *swig_obj[1] ;
18929
18930 if (!args) SWIG_fail;
18931 swig_obj[0] = args;
18932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18933 if (!SWIG_IsOK(res1)) {
18934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18935 }
18936 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18937 {
18938 PyThreadState* __tstate = wxPyBeginAllowThreads();
18939 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18940 wxPyEndAllowThreads(__tstate);
18941 if (PyErr_Occurred()) SWIG_fail;
18942 }
18943 {
18944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18945 }
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18953 PyObject *resultobj = 0;
18954 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18955 bool result;
18956 void *argp1 = 0 ;
18957 int res1 = 0 ;
18958 PyObject *swig_obj[1] ;
18959
18960 if (!args) SWIG_fail;
18961 swig_obj[0] = args;
18962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18963 if (!SWIG_IsOK(res1)) {
18964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18965 }
18966 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18967 {
18968 PyThreadState* __tstate = wxPyBeginAllowThreads();
18969 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18970 wxPyEndAllowThreads(__tstate);
18971 if (PyErr_Occurred()) SWIG_fail;
18972 }
18973 {
18974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18975 }
18976 return resultobj;
18977 fail:
18978 return NULL;
18979 }
18980
18981
18982 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18983 PyObject *resultobj = 0;
18984 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18985 long arg2 ;
18986 void *argp1 = 0 ;
18987 int res1 = 0 ;
18988 long val2 ;
18989 int ecode2 = 0 ;
18990 PyObject * obj0 = 0 ;
18991 PyObject * obj1 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "extraLong", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19000 }
19001 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19002 ecode2 = SWIG_AsVal_long(obj1, &val2);
19003 if (!SWIG_IsOK(ecode2)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19005 }
19006 arg2 = static_cast< long >(val2);
19007 {
19008 PyThreadState* __tstate = wxPyBeginAllowThreads();
19009 (arg1)->SetExtraLong(arg2);
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 resultobj = SWIG_Py_Void();
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19021 PyObject *resultobj = 0;
19022 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19023 long result;
19024 void *argp1 = 0 ;
19025 int res1 = 0 ;
19026 PyObject *swig_obj[1] ;
19027
19028 if (!args) SWIG_fail;
19029 swig_obj[0] = args;
19030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19031 if (!SWIG_IsOK(res1)) {
19032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19033 }
19034 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19035 {
19036 PyThreadState* __tstate = wxPyBeginAllowThreads();
19037 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 resultobj = SWIG_From_long(static_cast< long >(result));
19042 return resultobj;
19043 fail:
19044 return NULL;
19045 }
19046
19047
19048 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19049 PyObject *resultobj = 0;
19050 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19051 int arg2 ;
19052 void *argp1 = 0 ;
19053 int res1 = 0 ;
19054 int val2 ;
19055 int ecode2 = 0 ;
19056 PyObject * obj0 = 0 ;
19057 PyObject * obj1 = 0 ;
19058 char * kwnames[] = {
19059 (char *) "self",(char *) "i", NULL
19060 };
19061
19062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19064 if (!SWIG_IsOK(res1)) {
19065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19066 }
19067 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19068 ecode2 = SWIG_AsVal_int(obj1, &val2);
19069 if (!SWIG_IsOK(ecode2)) {
19070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19071 }
19072 arg2 = static_cast< int >(val2);
19073 {
19074 PyThreadState* __tstate = wxPyBeginAllowThreads();
19075 (arg1)->SetInt(arg2);
19076 wxPyEndAllowThreads(__tstate);
19077 if (PyErr_Occurred()) SWIG_fail;
19078 }
19079 resultobj = SWIG_Py_Void();
19080 return resultobj;
19081 fail:
19082 return NULL;
19083 }
19084
19085
19086 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19087 PyObject *resultobj = 0;
19088 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19089 long result;
19090 void *argp1 = 0 ;
19091 int res1 = 0 ;
19092 PyObject *swig_obj[1] ;
19093
19094 if (!args) SWIG_fail;
19095 swig_obj[0] = args;
19096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19097 if (!SWIG_IsOK(res1)) {
19098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19099 }
19100 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19104 wxPyEndAllowThreads(__tstate);
19105 if (PyErr_Occurred()) SWIG_fail;
19106 }
19107 resultobj = SWIG_From_long(static_cast< long >(result));
19108 return resultobj;
19109 fail:
19110 return NULL;
19111 }
19112
19113
19114 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19115 PyObject *resultobj = 0;
19116 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19117 PyObject *result = 0 ;
19118 void *argp1 = 0 ;
19119 int res1 = 0 ;
19120 PyObject *swig_obj[1] ;
19121
19122 if (!args) SWIG_fail;
19123 swig_obj[0] = args;
19124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19125 if (!SWIG_IsOK(res1)) {
19126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19127 }
19128 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19129 {
19130 PyThreadState* __tstate = wxPyBeginAllowThreads();
19131 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19132 wxPyEndAllowThreads(__tstate);
19133 if (PyErr_Occurred()) SWIG_fail;
19134 }
19135 resultobj = result;
19136 return resultobj;
19137 fail:
19138 return NULL;
19139 }
19140
19141
19142 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19143 PyObject *resultobj = 0;
19144 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19145 PyObject *arg2 = (PyObject *) 0 ;
19146 void *argp1 = 0 ;
19147 int res1 = 0 ;
19148 PyObject * obj0 = 0 ;
19149 PyObject * obj1 = 0 ;
19150 char * kwnames[] = {
19151 (char *) "self",(char *) "clientData", NULL
19152 };
19153
19154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19156 if (!SWIG_IsOK(res1)) {
19157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19158 }
19159 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19160 arg2 = obj1;
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 wxCommandEvent_SetClientData(arg1,arg2);
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = SWIG_Py_Void();
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19175 PyObject *resultobj = 0;
19176 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19177 wxEvent *result = 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 PyObject *swig_obj[1] ;
19181
19182 if (!args) SWIG_fail;
19183 swig_obj[0] = args;
19184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19185 if (!SWIG_IsOK(res1)) {
19186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19187 }
19188 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *obj;
19204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19205 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19206 return SWIG_Py_Void();
19207 }
19208
19209 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19210 return SWIG_Python_InitShadowInstance(args);
19211 }
19212
19213 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj = 0;
19215 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19216 int arg2 = (int) 0 ;
19217 wxNotifyEvent *result = 0 ;
19218 int val1 ;
19219 int ecode1 = 0 ;
19220 int val2 ;
19221 int ecode2 = 0 ;
19222 PyObject * obj0 = 0 ;
19223 PyObject * obj1 = 0 ;
19224 char * kwnames[] = {
19225 (char *) "commandType",(char *) "winid", NULL
19226 };
19227
19228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19229 if (obj0) {
19230 ecode1 = SWIG_AsVal_int(obj0, &val1);
19231 if (!SWIG_IsOK(ecode1)) {
19232 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19233 }
19234 arg1 = static_cast< wxEventType >(val1);
19235 }
19236 if (obj1) {
19237 ecode2 = SWIG_AsVal_int(obj1, &val2);
19238 if (!SWIG_IsOK(ecode2)) {
19239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19240 }
19241 arg2 = static_cast< int >(val2);
19242 }
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19257 PyObject *resultobj = 0;
19258 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19259 void *argp1 = 0 ;
19260 int res1 = 0 ;
19261 PyObject *swig_obj[1] ;
19262
19263 if (!args) SWIG_fail;
19264 swig_obj[0] = args;
19265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19266 if (!SWIG_IsOK(res1)) {
19267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19268 }
19269 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 (arg1)->Veto();
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 resultobj = SWIG_Py_Void();
19277 return resultobj;
19278 fail:
19279 return NULL;
19280 }
19281
19282
19283 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19284 PyObject *resultobj = 0;
19285 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19286 void *argp1 = 0 ;
19287 int res1 = 0 ;
19288 PyObject *swig_obj[1] ;
19289
19290 if (!args) SWIG_fail;
19291 swig_obj[0] = args;
19292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19293 if (!SWIG_IsOK(res1)) {
19294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19295 }
19296 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19297 {
19298 PyThreadState* __tstate = wxPyBeginAllowThreads();
19299 (arg1)->Allow();
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 resultobj = SWIG_Py_Void();
19304 return resultobj;
19305 fail:
19306 return NULL;
19307 }
19308
19309
19310 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19311 PyObject *resultobj = 0;
19312 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19313 bool result;
19314 void *argp1 = 0 ;
19315 int res1 = 0 ;
19316 PyObject *swig_obj[1] ;
19317
19318 if (!args) SWIG_fail;
19319 swig_obj[0] = args;
19320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19321 if (!SWIG_IsOK(res1)) {
19322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19323 }
19324 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19325 {
19326 PyThreadState* __tstate = wxPyBeginAllowThreads();
19327 result = (bool)(arg1)->IsAllowed();
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 {
19332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19333 }
19334 return resultobj;
19335 fail:
19336 return NULL;
19337 }
19338
19339
19340 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19341 PyObject *obj;
19342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19343 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19344 return SWIG_Py_Void();
19345 }
19346
19347 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19348 return SWIG_Python_InitShadowInstance(args);
19349 }
19350
19351 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19352 PyObject *resultobj = 0;
19353 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19354 int arg2 = (int) 0 ;
19355 int arg3 = (int) 0 ;
19356 int arg4 = (int) 0 ;
19357 wxScrollEvent *result = 0 ;
19358 int val1 ;
19359 int ecode1 = 0 ;
19360 int val2 ;
19361 int ecode2 = 0 ;
19362 int val3 ;
19363 int ecode3 = 0 ;
19364 int val4 ;
19365 int ecode4 = 0 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 PyObject * obj2 = 0 ;
19369 PyObject * obj3 = 0 ;
19370 char * kwnames[] = {
19371 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19372 };
19373
19374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19375 if (obj0) {
19376 ecode1 = SWIG_AsVal_int(obj0, &val1);
19377 if (!SWIG_IsOK(ecode1)) {
19378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19379 }
19380 arg1 = static_cast< wxEventType >(val1);
19381 }
19382 if (obj1) {
19383 ecode2 = SWIG_AsVal_int(obj1, &val2);
19384 if (!SWIG_IsOK(ecode2)) {
19385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19386 }
19387 arg2 = static_cast< int >(val2);
19388 }
19389 if (obj2) {
19390 ecode3 = SWIG_AsVal_int(obj2, &val3);
19391 if (!SWIG_IsOK(ecode3)) {
19392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19393 }
19394 arg3 = static_cast< int >(val3);
19395 }
19396 if (obj3) {
19397 ecode4 = SWIG_AsVal_int(obj3, &val4);
19398 if (!SWIG_IsOK(ecode4)) {
19399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19400 }
19401 arg4 = static_cast< int >(val4);
19402 }
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19417 PyObject *resultobj = 0;
19418 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19419 int result;
19420 void *argp1 = 0 ;
19421 int res1 = 0 ;
19422 PyObject *swig_obj[1] ;
19423
19424 if (!args) SWIG_fail;
19425 swig_obj[0] = args;
19426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19429 }
19430 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19431 {
19432 PyThreadState* __tstate = wxPyBeginAllowThreads();
19433 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19434 wxPyEndAllowThreads(__tstate);
19435 if (PyErr_Occurred()) SWIG_fail;
19436 }
19437 resultobj = SWIG_From_int(static_cast< int >(result));
19438 return resultobj;
19439 fail:
19440 return NULL;
19441 }
19442
19443
19444 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19445 PyObject *resultobj = 0;
19446 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19447 int result;
19448 void *argp1 = 0 ;
19449 int res1 = 0 ;
19450 PyObject *swig_obj[1] ;
19451
19452 if (!args) SWIG_fail;
19453 swig_obj[0] = args;
19454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19455 if (!SWIG_IsOK(res1)) {
19456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19457 }
19458 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19462 wxPyEndAllowThreads(__tstate);
19463 if (PyErr_Occurred()) SWIG_fail;
19464 }
19465 resultobj = SWIG_From_int(static_cast< int >(result));
19466 return resultobj;
19467 fail:
19468 return NULL;
19469 }
19470
19471
19472 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19473 PyObject *resultobj = 0;
19474 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19475 int arg2 ;
19476 void *argp1 = 0 ;
19477 int res1 = 0 ;
19478 int val2 ;
19479 int ecode2 = 0 ;
19480 PyObject * obj0 = 0 ;
19481 PyObject * obj1 = 0 ;
19482 char * kwnames[] = {
19483 (char *) "self",(char *) "orient", NULL
19484 };
19485
19486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19488 if (!SWIG_IsOK(res1)) {
19489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19490 }
19491 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19492 ecode2 = SWIG_AsVal_int(obj1, &val2);
19493 if (!SWIG_IsOK(ecode2)) {
19494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19495 }
19496 arg2 = static_cast< int >(val2);
19497 {
19498 PyThreadState* __tstate = wxPyBeginAllowThreads();
19499 (arg1)->SetOrientation(arg2);
19500 wxPyEndAllowThreads(__tstate);
19501 if (PyErr_Occurred()) SWIG_fail;
19502 }
19503 resultobj = SWIG_Py_Void();
19504 return resultobj;
19505 fail:
19506 return NULL;
19507 }
19508
19509
19510 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19511 PyObject *resultobj = 0;
19512 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19513 int arg2 ;
19514 void *argp1 = 0 ;
19515 int res1 = 0 ;
19516 int val2 ;
19517 int ecode2 = 0 ;
19518 PyObject * obj0 = 0 ;
19519 PyObject * obj1 = 0 ;
19520 char * kwnames[] = {
19521 (char *) "self",(char *) "pos", NULL
19522 };
19523
19524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19526 if (!SWIG_IsOK(res1)) {
19527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19528 }
19529 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19530 ecode2 = SWIG_AsVal_int(obj1, &val2);
19531 if (!SWIG_IsOK(ecode2)) {
19532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19533 }
19534 arg2 = static_cast< int >(val2);
19535 {
19536 PyThreadState* __tstate = wxPyBeginAllowThreads();
19537 (arg1)->SetPosition(arg2);
19538 wxPyEndAllowThreads(__tstate);
19539 if (PyErr_Occurred()) SWIG_fail;
19540 }
19541 resultobj = SWIG_Py_Void();
19542 return resultobj;
19543 fail:
19544 return NULL;
19545 }
19546
19547
19548 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19549 PyObject *obj;
19550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19551 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19552 return SWIG_Py_Void();
19553 }
19554
19555 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19556 return SWIG_Python_InitShadowInstance(args);
19557 }
19558
19559 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19560 PyObject *resultobj = 0;
19561 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19562 int arg2 = (int) 0 ;
19563 int arg3 = (int) 0 ;
19564 wxScrollWinEvent *result = 0 ;
19565 int val1 ;
19566 int ecode1 = 0 ;
19567 int val2 ;
19568 int ecode2 = 0 ;
19569 int val3 ;
19570 int ecode3 = 0 ;
19571 PyObject * obj0 = 0 ;
19572 PyObject * obj1 = 0 ;
19573 PyObject * obj2 = 0 ;
19574 char * kwnames[] = {
19575 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19576 };
19577
19578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19579 if (obj0) {
19580 ecode1 = SWIG_AsVal_int(obj0, &val1);
19581 if (!SWIG_IsOK(ecode1)) {
19582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19583 }
19584 arg1 = static_cast< wxEventType >(val1);
19585 }
19586 if (obj1) {
19587 ecode2 = SWIG_AsVal_int(obj1, &val2);
19588 if (!SWIG_IsOK(ecode2)) {
19589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19590 }
19591 arg2 = static_cast< int >(val2);
19592 }
19593 if (obj2) {
19594 ecode3 = SWIG_AsVal_int(obj2, &val3);
19595 if (!SWIG_IsOK(ecode3)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19597 }
19598 arg3 = static_cast< int >(val3);
19599 }
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19614 PyObject *resultobj = 0;
19615 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19616 int result;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 PyObject *swig_obj[1] ;
19620
19621 if (!args) SWIG_fail;
19622 swig_obj[0] = args;
19623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19624 if (!SWIG_IsOK(res1)) {
19625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19626 }
19627 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_From_int(static_cast< int >(result));
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19642 PyObject *resultobj = 0;
19643 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19644 int result;
19645 void *argp1 = 0 ;
19646 int res1 = 0 ;
19647 PyObject *swig_obj[1] ;
19648
19649 if (!args) SWIG_fail;
19650 swig_obj[0] = args;
19651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19652 if (!SWIG_IsOK(res1)) {
19653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19654 }
19655 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19656 {
19657 PyThreadState* __tstate = wxPyBeginAllowThreads();
19658 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19659 wxPyEndAllowThreads(__tstate);
19660 if (PyErr_Occurred()) SWIG_fail;
19661 }
19662 resultobj = SWIG_From_int(static_cast< int >(result));
19663 return resultobj;
19664 fail:
19665 return NULL;
19666 }
19667
19668
19669 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19670 PyObject *resultobj = 0;
19671 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19672 int arg2 ;
19673 void *argp1 = 0 ;
19674 int res1 = 0 ;
19675 int val2 ;
19676 int ecode2 = 0 ;
19677 PyObject * obj0 = 0 ;
19678 PyObject * obj1 = 0 ;
19679 char * kwnames[] = {
19680 (char *) "self",(char *) "orient", NULL
19681 };
19682
19683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19685 if (!SWIG_IsOK(res1)) {
19686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19687 }
19688 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19689 ecode2 = SWIG_AsVal_int(obj1, &val2);
19690 if (!SWIG_IsOK(ecode2)) {
19691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19692 }
19693 arg2 = static_cast< int >(val2);
19694 {
19695 PyThreadState* __tstate = wxPyBeginAllowThreads();
19696 (arg1)->SetOrientation(arg2);
19697 wxPyEndAllowThreads(__tstate);
19698 if (PyErr_Occurred()) SWIG_fail;
19699 }
19700 resultobj = SWIG_Py_Void();
19701 return resultobj;
19702 fail:
19703 return NULL;
19704 }
19705
19706
19707 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19708 PyObject *resultobj = 0;
19709 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19710 int arg2 ;
19711 void *argp1 = 0 ;
19712 int res1 = 0 ;
19713 int val2 ;
19714 int ecode2 = 0 ;
19715 PyObject * obj0 = 0 ;
19716 PyObject * obj1 = 0 ;
19717 char * kwnames[] = {
19718 (char *) "self",(char *) "pos", NULL
19719 };
19720
19721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19725 }
19726 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19727 ecode2 = SWIG_AsVal_int(obj1, &val2);
19728 if (!SWIG_IsOK(ecode2)) {
19729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19730 }
19731 arg2 = static_cast< int >(val2);
19732 {
19733 PyThreadState* __tstate = wxPyBeginAllowThreads();
19734 (arg1)->SetPosition(arg2);
19735 wxPyEndAllowThreads(__tstate);
19736 if (PyErr_Occurred()) SWIG_fail;
19737 }
19738 resultobj = SWIG_Py_Void();
19739 return resultobj;
19740 fail:
19741 return NULL;
19742 }
19743
19744
19745 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19746 PyObject *obj;
19747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19748 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19749 return SWIG_Py_Void();
19750 }
19751
19752 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19753 return SWIG_Python_InitShadowInstance(args);
19754 }
19755
19756 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19759 wxMouseEvent *result = 0 ;
19760 int val1 ;
19761 int ecode1 = 0 ;
19762 PyObject * obj0 = 0 ;
19763 char * kwnames[] = {
19764 (char *) "mouseType", NULL
19765 };
19766
19767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19768 if (obj0) {
19769 ecode1 = SWIG_AsVal_int(obj0, &val1);
19770 if (!SWIG_IsOK(ecode1)) {
19771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19772 }
19773 arg1 = static_cast< wxEventType >(val1);
19774 }
19775 {
19776 PyThreadState* __tstate = wxPyBeginAllowThreads();
19777 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19778 wxPyEndAllowThreads(__tstate);
19779 if (PyErr_Occurred()) SWIG_fail;
19780 }
19781 {
19782 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19783 }
19784 return resultobj;
19785 fail:
19786 return NULL;
19787 }
19788
19789
19790 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19791 PyObject *resultobj = 0;
19792 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19793 bool result;
19794 void *argp1 = 0 ;
19795 int res1 = 0 ;
19796 PyObject *swig_obj[1] ;
19797
19798 if (!args) SWIG_fail;
19799 swig_obj[0] = args;
19800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19803 }
19804 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19805 {
19806 PyThreadState* __tstate = wxPyBeginAllowThreads();
19807 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19808 wxPyEndAllowThreads(__tstate);
19809 if (PyErr_Occurred()) SWIG_fail;
19810 }
19811 {
19812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19813 }
19814 return resultobj;
19815 fail:
19816 return NULL;
19817 }
19818
19819
19820 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19821 PyObject *resultobj = 0;
19822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19823 int arg2 = (int) wxMOUSE_BTN_ANY ;
19824 bool result;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 int val2 ;
19828 int ecode2 = 0 ;
19829 PyObject * obj0 = 0 ;
19830 PyObject * obj1 = 0 ;
19831 char * kwnames[] = {
19832 (char *) "self",(char *) "but", NULL
19833 };
19834
19835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19837 if (!SWIG_IsOK(res1)) {
19838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19839 }
19840 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19841 if (obj1) {
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 }
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 {
19855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19856 }
19857 return resultobj;
19858 fail:
19859 return NULL;
19860 }
19861
19862
19863 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19864 PyObject *resultobj = 0;
19865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19866 int arg2 = (int) wxMOUSE_BTN_ANY ;
19867 bool result;
19868 void *argp1 = 0 ;
19869 int res1 = 0 ;
19870 int val2 ;
19871 int ecode2 = 0 ;
19872 PyObject * obj0 = 0 ;
19873 PyObject * obj1 = 0 ;
19874 char * kwnames[] = {
19875 (char *) "self",(char *) "but", NULL
19876 };
19877
19878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19880 if (!SWIG_IsOK(res1)) {
19881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19882 }
19883 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19884 if (obj1) {
19885 ecode2 = SWIG_AsVal_int(obj1, &val2);
19886 if (!SWIG_IsOK(ecode2)) {
19887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19888 }
19889 arg2 = static_cast< int >(val2);
19890 }
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19899 }
19900 return resultobj;
19901 fail:
19902 return NULL;
19903 }
19904
19905
19906 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19907 PyObject *resultobj = 0;
19908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19909 int arg2 = (int) wxMOUSE_BTN_ANY ;
19910 bool result;
19911 void *argp1 = 0 ;
19912 int res1 = 0 ;
19913 int val2 ;
19914 int ecode2 = 0 ;
19915 PyObject * obj0 = 0 ;
19916 PyObject * obj1 = 0 ;
19917 char * kwnames[] = {
19918 (char *) "self",(char *) "but", NULL
19919 };
19920
19921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19923 if (!SWIG_IsOK(res1)) {
19924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19925 }
19926 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19927 if (obj1) {
19928 ecode2 = SWIG_AsVal_int(obj1, &val2);
19929 if (!SWIG_IsOK(ecode2)) {
19930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19931 }
19932 arg2 = static_cast< int >(val2);
19933 }
19934 {
19935 PyThreadState* __tstate = wxPyBeginAllowThreads();
19936 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 {
19941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19942 }
19943 return resultobj;
19944 fail:
19945 return NULL;
19946 }
19947
19948
19949 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19950 PyObject *resultobj = 0;
19951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19952 int arg2 ;
19953 bool result;
19954 void *argp1 = 0 ;
19955 int res1 = 0 ;
19956 int val2 ;
19957 int ecode2 = 0 ;
19958 PyObject * obj0 = 0 ;
19959 PyObject * obj1 = 0 ;
19960 char * kwnames[] = {
19961 (char *) "self",(char *) "button", NULL
19962 };
19963
19964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19966 if (!SWIG_IsOK(res1)) {
19967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19968 }
19969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19970 ecode2 = SWIG_AsVal_int(obj1, &val2);
19971 if (!SWIG_IsOK(ecode2)) {
19972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19973 }
19974 arg2 = static_cast< int >(val2);
19975 {
19976 PyThreadState* __tstate = wxPyBeginAllowThreads();
19977 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19978 wxPyEndAllowThreads(__tstate);
19979 if (PyErr_Occurred()) SWIG_fail;
19980 }
19981 {
19982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19983 }
19984 return resultobj;
19985 fail:
19986 return NULL;
19987 }
19988
19989
19990 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19991 PyObject *resultobj = 0;
19992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19993 int arg2 ;
19994 bool result;
19995 void *argp1 = 0 ;
19996 int res1 = 0 ;
19997 int val2 ;
19998 int ecode2 = 0 ;
19999 PyObject * obj0 = 0 ;
20000 PyObject * obj1 = 0 ;
20001 char * kwnames[] = {
20002 (char *) "self",(char *) "but", NULL
20003 };
20004
20005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20007 if (!SWIG_IsOK(res1)) {
20008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20009 }
20010 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20011 ecode2 = SWIG_AsVal_int(obj1, &val2);
20012 if (!SWIG_IsOK(ecode2)) {
20013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20014 }
20015 arg2 = static_cast< int >(val2);
20016 {
20017 PyThreadState* __tstate = wxPyBeginAllowThreads();
20018 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20019 wxPyEndAllowThreads(__tstate);
20020 if (PyErr_Occurred()) SWIG_fail;
20021 }
20022 {
20023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20024 }
20025 return resultobj;
20026 fail:
20027 return NULL;
20028 }
20029
20030
20031 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20032 PyObject *resultobj = 0;
20033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20034 int result;
20035 void *argp1 = 0 ;
20036 int res1 = 0 ;
20037 PyObject *swig_obj[1] ;
20038
20039 if (!args) SWIG_fail;
20040 swig_obj[0] = args;
20041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20042 if (!SWIG_IsOK(res1)) {
20043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20044 }
20045 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20046 {
20047 PyThreadState* __tstate = wxPyBeginAllowThreads();
20048 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20049 wxPyEndAllowThreads(__tstate);
20050 if (PyErr_Occurred()) SWIG_fail;
20051 }
20052 resultobj = SWIG_From_int(static_cast< int >(result));
20053 return resultobj;
20054 fail:
20055 return NULL;
20056 }
20057
20058
20059 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20060 PyObject *resultobj = 0;
20061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20062 bool result;
20063 void *argp1 = 0 ;
20064 int res1 = 0 ;
20065 PyObject *swig_obj[1] ;
20066
20067 if (!args) SWIG_fail;
20068 swig_obj[0] = args;
20069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20070 if (!SWIG_IsOK(res1)) {
20071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20072 }
20073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20077 wxPyEndAllowThreads(__tstate);
20078 if (PyErr_Occurred()) SWIG_fail;
20079 }
20080 {
20081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20082 }
20083 return resultobj;
20084 fail:
20085 return NULL;
20086 }
20087
20088
20089 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20090 PyObject *resultobj = 0;
20091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20092 bool result;
20093 void *argp1 = 0 ;
20094 int res1 = 0 ;
20095 PyObject *swig_obj[1] ;
20096
20097 if (!args) SWIG_fail;
20098 swig_obj[0] = args;
20099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20100 if (!SWIG_IsOK(res1)) {
20101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20102 }
20103 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20107 wxPyEndAllowThreads(__tstate);
20108 if (PyErr_Occurred()) SWIG_fail;
20109 }
20110 {
20111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20112 }
20113 return resultobj;
20114 fail:
20115 return NULL;
20116 }
20117
20118
20119 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20120 PyObject *resultobj = 0;
20121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20122 bool result;
20123 void *argp1 = 0 ;
20124 int res1 = 0 ;
20125 PyObject *swig_obj[1] ;
20126
20127 if (!args) SWIG_fail;
20128 swig_obj[0] = args;
20129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20130 if (!SWIG_IsOK(res1)) {
20131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20132 }
20133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20134 {
20135 PyThreadState* __tstate = wxPyBeginAllowThreads();
20136 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20137 wxPyEndAllowThreads(__tstate);
20138 if (PyErr_Occurred()) SWIG_fail;
20139 }
20140 {
20141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20142 }
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20150 PyObject *resultobj = 0;
20151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20152 bool result;
20153 void *argp1 = 0 ;
20154 int res1 = 0 ;
20155 PyObject *swig_obj[1] ;
20156
20157 if (!args) SWIG_fail;
20158 swig_obj[0] = args;
20159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20160 if (!SWIG_IsOK(res1)) {
20161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20162 }
20163 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20164 {
20165 PyThreadState* __tstate = wxPyBeginAllowThreads();
20166 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 {
20171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20172 }
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20180 PyObject *resultobj = 0;
20181 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20182 bool result;
20183 void *argp1 = 0 ;
20184 int res1 = 0 ;
20185 PyObject *swig_obj[1] ;
20186
20187 if (!args) SWIG_fail;
20188 swig_obj[0] = args;
20189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20190 if (!SWIG_IsOK(res1)) {
20191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20192 }
20193 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20197 wxPyEndAllowThreads(__tstate);
20198 if (PyErr_Occurred()) SWIG_fail;
20199 }
20200 {
20201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20202 }
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 PyObject *resultobj = 0;
20211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20212 bool result;
20213 void *argp1 = 0 ;
20214 int res1 = 0 ;
20215 PyObject *swig_obj[1] ;
20216
20217 if (!args) SWIG_fail;
20218 swig_obj[0] = args;
20219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20222 }
20223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *resultobj = 0;
20241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20242 bool result;
20243 void *argp1 = 0 ;
20244 int res1 = 0 ;
20245 PyObject *swig_obj[1] ;
20246
20247 if (!args) SWIG_fail;
20248 swig_obj[0] = args;
20249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20250 if (!SWIG_IsOK(res1)) {
20251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20252 }
20253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20254 {
20255 PyThreadState* __tstate = wxPyBeginAllowThreads();
20256 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 {
20261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20262 }
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20270 PyObject *resultobj = 0;
20271 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20272 bool result;
20273 void *argp1 = 0 ;
20274 int res1 = 0 ;
20275 PyObject *swig_obj[1] ;
20276
20277 if (!args) SWIG_fail;
20278 swig_obj[0] = args;
20279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20280 if (!SWIG_IsOK(res1)) {
20281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20282 }
20283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20287 wxPyEndAllowThreads(__tstate);
20288 if (PyErr_Occurred()) SWIG_fail;
20289 }
20290 {
20291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20292 }
20293 return resultobj;
20294 fail:
20295 return NULL;
20296 }
20297
20298
20299 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20300 PyObject *resultobj = 0;
20301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20302 bool 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_wxMouseEvent, 0 | 0 );
20310 if (!SWIG_IsOK(res1)) {
20311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20312 }
20313 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20322 }
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20332 bool result;
20333 void *argp1 = 0 ;
20334 int res1 = 0 ;
20335 PyObject *swig_obj[1] ;
20336
20337 if (!args) SWIG_fail;
20338 swig_obj[0] = args;
20339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20340 if (!SWIG_IsOK(res1)) {
20341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20342 }
20343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20344 {
20345 PyThreadState* __tstate = wxPyBeginAllowThreads();
20346 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20347 wxPyEndAllowThreads(__tstate);
20348 if (PyErr_Occurred()) SWIG_fail;
20349 }
20350 {
20351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20352 }
20353 return resultobj;
20354 fail:
20355 return NULL;
20356 }
20357
20358
20359 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20360 PyObject *resultobj = 0;
20361 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20362 bool result;
20363 void *argp1 = 0 ;
20364 int res1 = 0 ;
20365 PyObject *swig_obj[1] ;
20366
20367 if (!args) SWIG_fail;
20368 swig_obj[0] = args;
20369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20370 if (!SWIG_IsOK(res1)) {
20371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20372 }
20373 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20374 {
20375 PyThreadState* __tstate = wxPyBeginAllowThreads();
20376 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 {
20381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20390 PyObject *resultobj = 0;
20391 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20392 bool result;
20393 void *argp1 = 0 ;
20394 int res1 = 0 ;
20395 PyObject *swig_obj[1] ;
20396
20397 if (!args) SWIG_fail;
20398 swig_obj[0] = args;
20399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20400 if (!SWIG_IsOK(res1)) {
20401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20402 }
20403 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20404 {
20405 PyThreadState* __tstate = wxPyBeginAllowThreads();
20406 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20407 wxPyEndAllowThreads(__tstate);
20408 if (PyErr_Occurred()) SWIG_fail;
20409 }
20410 {
20411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20412 }
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *resultobj = 0;
20421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20422 bool result;
20423 void *argp1 = 0 ;
20424 int res1 = 0 ;
20425 PyObject *swig_obj[1] ;
20426
20427 if (!args) SWIG_fail;
20428 swig_obj[0] = args;
20429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20430 if (!SWIG_IsOK(res1)) {
20431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20432 }
20433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 {
20441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20442 }
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20450 PyObject *resultobj = 0;
20451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20452 bool result;
20453 void *argp1 = 0 ;
20454 int res1 = 0 ;
20455 PyObject *swig_obj[1] ;
20456
20457 if (!args) SWIG_fail;
20458 swig_obj[0] = args;
20459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20460 if (!SWIG_IsOK(res1)) {
20461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20462 }
20463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20467 wxPyEndAllowThreads(__tstate);
20468 if (PyErr_Occurred()) SWIG_fail;
20469 }
20470 {
20471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20472 }
20473 return resultobj;
20474 fail:
20475 return NULL;
20476 }
20477
20478
20479 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20480 PyObject *resultobj = 0;
20481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20482 bool result;
20483 void *argp1 = 0 ;
20484 int res1 = 0 ;
20485 PyObject *swig_obj[1] ;
20486
20487 if (!args) SWIG_fail;
20488 swig_obj[0] = args;
20489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20490 if (!SWIG_IsOK(res1)) {
20491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20492 }
20493 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (bool)(arg1)->LeftIsDown();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 {
20501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20502 }
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20510 PyObject *resultobj = 0;
20511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20512 bool result;
20513 void *argp1 = 0 ;
20514 int res1 = 0 ;
20515 PyObject *swig_obj[1] ;
20516
20517 if (!args) SWIG_fail;
20518 swig_obj[0] = args;
20519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20520 if (!SWIG_IsOK(res1)) {
20521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20522 }
20523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20524 {
20525 PyThreadState* __tstate = wxPyBeginAllowThreads();
20526 result = (bool)(arg1)->MiddleIsDown();
20527 wxPyEndAllowThreads(__tstate);
20528 if (PyErr_Occurred()) SWIG_fail;
20529 }
20530 {
20531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20532 }
20533 return resultobj;
20534 fail:
20535 return NULL;
20536 }
20537
20538
20539 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20540 PyObject *resultobj = 0;
20541 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20542 bool result;
20543 void *argp1 = 0 ;
20544 int res1 = 0 ;
20545 PyObject *swig_obj[1] ;
20546
20547 if (!args) SWIG_fail;
20548 swig_obj[0] = args;
20549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20550 if (!SWIG_IsOK(res1)) {
20551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20552 }
20553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (bool)(arg1)->RightIsDown();
20557 wxPyEndAllowThreads(__tstate);
20558 if (PyErr_Occurred()) SWIG_fail;
20559 }
20560 {
20561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20562 }
20563 return resultobj;
20564 fail:
20565 return NULL;
20566 }
20567
20568
20569 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20570 PyObject *resultobj = 0;
20571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20572 bool result;
20573 void *argp1 = 0 ;
20574 int res1 = 0 ;
20575 PyObject *swig_obj[1] ;
20576
20577 if (!args) SWIG_fail;
20578 swig_obj[0] = args;
20579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20580 if (!SWIG_IsOK(res1)) {
20581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20582 }
20583 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20584 {
20585 PyThreadState* __tstate = wxPyBeginAllowThreads();
20586 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20600 PyObject *resultobj = 0;
20601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20602 bool result;
20603 void *argp1 = 0 ;
20604 int res1 = 0 ;
20605 PyObject *swig_obj[1] ;
20606
20607 if (!args) SWIG_fail;
20608 swig_obj[0] = args;
20609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20610 if (!SWIG_IsOK(res1)) {
20611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20612 }
20613 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20614 {
20615 PyThreadState* __tstate = wxPyBeginAllowThreads();
20616 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20617 wxPyEndAllowThreads(__tstate);
20618 if (PyErr_Occurred()) SWIG_fail;
20619 }
20620 {
20621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20622 }
20623 return resultobj;
20624 fail:
20625 return NULL;
20626 }
20627
20628
20629 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20630 PyObject *resultobj = 0;
20631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20632 bool result;
20633 void *argp1 = 0 ;
20634 int res1 = 0 ;
20635 PyObject *swig_obj[1] ;
20636
20637 if (!args) SWIG_fail;
20638 swig_obj[0] = args;
20639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20640 if (!SWIG_IsOK(res1)) {
20641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20642 }
20643 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20644 {
20645 PyThreadState* __tstate = wxPyBeginAllowThreads();
20646 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20647 wxPyEndAllowThreads(__tstate);
20648 if (PyErr_Occurred()) SWIG_fail;
20649 }
20650 {
20651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20652 }
20653 return resultobj;
20654 fail:
20655 return NULL;
20656 }
20657
20658
20659 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20660 PyObject *resultobj = 0;
20661 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20662 bool result;
20663 void *argp1 = 0 ;
20664 int res1 = 0 ;
20665 PyObject *swig_obj[1] ;
20666
20667 if (!args) SWIG_fail;
20668 swig_obj[0] = args;
20669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20670 if (!SWIG_IsOK(res1)) {
20671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20672 }
20673 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20674 {
20675 PyThreadState* __tstate = wxPyBeginAllowThreads();
20676 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 {
20681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20682 }
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20690 PyObject *resultobj = 0;
20691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20692 wxPoint result;
20693 void *argp1 = 0 ;
20694 int res1 = 0 ;
20695 PyObject *swig_obj[1] ;
20696
20697 if (!args) SWIG_fail;
20698 swig_obj[0] = args;
20699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20700 if (!SWIG_IsOK(res1)) {
20701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20702 }
20703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (arg1)->GetPosition();
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20718 PyObject *resultobj = 0;
20719 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20720 long *arg2 = (long *) 0 ;
20721 long *arg3 = (long *) 0 ;
20722 void *argp1 = 0 ;
20723 int res1 = 0 ;
20724 long temp2 ;
20725 int res2 = SWIG_TMPOBJ ;
20726 long temp3 ;
20727 int res3 = SWIG_TMPOBJ ;
20728 PyObject *swig_obj[1] ;
20729
20730 arg2 = &temp2;
20731 arg3 = &temp3;
20732 if (!args) SWIG_fail;
20733 swig_obj[0] = args;
20734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20735 if (!SWIG_IsOK(res1)) {
20736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20737 }
20738 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20739 {
20740 PyThreadState* __tstate = wxPyBeginAllowThreads();
20741 (arg1)->GetPosition(arg2,arg3);
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 resultobj = SWIG_Py_Void();
20746 if (SWIG_IsTmpObj(res2)) {
20747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20748 } else {
20749 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20751 }
20752 if (SWIG_IsTmpObj(res3)) {
20753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20754 } else {
20755 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20757 }
20758 return resultobj;
20759 fail:
20760 return NULL;
20761 }
20762
20763
20764 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20765 PyObject *resultobj = 0;
20766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20767 wxDC *arg2 = 0 ;
20768 wxPoint result;
20769 void *argp1 = 0 ;
20770 int res1 = 0 ;
20771 void *argp2 = 0 ;
20772 int res2 = 0 ;
20773 PyObject * obj0 = 0 ;
20774 PyObject * obj1 = 0 ;
20775 char * kwnames[] = {
20776 (char *) "self",(char *) "dc", NULL
20777 };
20778
20779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20781 if (!SWIG_IsOK(res1)) {
20782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20783 }
20784 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20786 if (!SWIG_IsOK(res2)) {
20787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20788 }
20789 if (!argp2) {
20790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20791 }
20792 arg2 = reinterpret_cast< wxDC * >(argp2);
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20796 wxPyEndAllowThreads(__tstate);
20797 if (PyErr_Occurred()) SWIG_fail;
20798 }
20799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20800 return resultobj;
20801 fail:
20802 return NULL;
20803 }
20804
20805
20806 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20807 PyObject *resultobj = 0;
20808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20809 int result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 PyObject *swig_obj[1] ;
20813
20814 if (!args) SWIG_fail;
20815 swig_obj[0] = args;
20816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20819 }
20820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = (int)((wxMouseEvent const *)arg1)->GetX();
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 resultobj = SWIG_From_int(static_cast< int >(result));
20828 return resultobj;
20829 fail:
20830 return NULL;
20831 }
20832
20833
20834 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20835 PyObject *resultobj = 0;
20836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20837 int result;
20838 void *argp1 = 0 ;
20839 int res1 = 0 ;
20840 PyObject *swig_obj[1] ;
20841
20842 if (!args) SWIG_fail;
20843 swig_obj[0] = args;
20844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20845 if (!SWIG_IsOK(res1)) {
20846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20847 }
20848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (int)((wxMouseEvent const *)arg1)->GetY();
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 resultobj = SWIG_From_int(static_cast< int >(result));
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20863 PyObject *resultobj = 0;
20864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20865 int result;
20866 void *argp1 = 0 ;
20867 int res1 = 0 ;
20868 PyObject *swig_obj[1] ;
20869
20870 if (!args) SWIG_fail;
20871 swig_obj[0] = args;
20872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20873 if (!SWIG_IsOK(res1)) {
20874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20875 }
20876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20877 {
20878 PyThreadState* __tstate = wxPyBeginAllowThreads();
20879 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20880 wxPyEndAllowThreads(__tstate);
20881 if (PyErr_Occurred()) SWIG_fail;
20882 }
20883 resultobj = SWIG_From_int(static_cast< int >(result));
20884 return resultobj;
20885 fail:
20886 return NULL;
20887 }
20888
20889
20890 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20891 PyObject *resultobj = 0;
20892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20893 int result;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 PyObject *swig_obj[1] ;
20897
20898 if (!args) SWIG_fail;
20899 swig_obj[0] = args;
20900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20901 if (!SWIG_IsOK(res1)) {
20902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20903 }
20904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20905 {
20906 PyThreadState* __tstate = wxPyBeginAllowThreads();
20907 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20908 wxPyEndAllowThreads(__tstate);
20909 if (PyErr_Occurred()) SWIG_fail;
20910 }
20911 resultobj = SWIG_From_int(static_cast< int >(result));
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20919 PyObject *resultobj = 0;
20920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20921 int result;
20922 void *argp1 = 0 ;
20923 int res1 = 0 ;
20924 PyObject *swig_obj[1] ;
20925
20926 if (!args) SWIG_fail;
20927 swig_obj[0] = args;
20928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20929 if (!SWIG_IsOK(res1)) {
20930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20931 }
20932 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 resultobj = SWIG_From_int(static_cast< int >(result));
20940 return resultobj;
20941 fail:
20942 return NULL;
20943 }
20944
20945
20946 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20947 PyObject *resultobj = 0;
20948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20949 bool result;
20950 void *argp1 = 0 ;
20951 int res1 = 0 ;
20952 PyObject *swig_obj[1] ;
20953
20954 if (!args) SWIG_fail;
20955 swig_obj[0] = args;
20956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20957 if (!SWIG_IsOK(res1)) {
20958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20959 }
20960 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20961 {
20962 PyThreadState* __tstate = wxPyBeginAllowThreads();
20963 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20964 wxPyEndAllowThreads(__tstate);
20965 if (PyErr_Occurred()) SWIG_fail;
20966 }
20967 {
20968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20969 }
20970 return resultobj;
20971 fail:
20972 return NULL;
20973 }
20974
20975
20976 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20977 PyObject *resultobj = 0;
20978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20979 int arg2 ;
20980 void *argp1 = 0 ;
20981 int res1 = 0 ;
20982 int val2 ;
20983 int ecode2 = 0 ;
20984 PyObject *swig_obj[2] ;
20985
20986 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20990 }
20991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20992 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20993 if (!SWIG_IsOK(ecode2)) {
20994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20995 }
20996 arg2 = static_cast< int >(val2);
20997 if (arg1) (arg1)->m_x = arg2;
20998
20999 resultobj = SWIG_Py_Void();
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21007 PyObject *resultobj = 0;
21008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21009 int result;
21010 void *argp1 = 0 ;
21011 int res1 = 0 ;
21012 PyObject *swig_obj[1] ;
21013
21014 if (!args) SWIG_fail;
21015 swig_obj[0] = args;
21016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21019 }
21020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21021 result = (int) ((arg1)->m_x);
21022 resultobj = SWIG_From_int(static_cast< int >(result));
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21030 PyObject *resultobj = 0;
21031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21032 int arg2 ;
21033 void *argp1 = 0 ;
21034 int res1 = 0 ;
21035 int val2 ;
21036 int ecode2 = 0 ;
21037 PyObject *swig_obj[2] ;
21038
21039 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21041 if (!SWIG_IsOK(res1)) {
21042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21043 }
21044 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21045 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21046 if (!SWIG_IsOK(ecode2)) {
21047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21048 }
21049 arg2 = static_cast< int >(val2);
21050 if (arg1) (arg1)->m_y = arg2;
21051
21052 resultobj = SWIG_Py_Void();
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21060 PyObject *resultobj = 0;
21061 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21062 int result;
21063 void *argp1 = 0 ;
21064 int res1 = 0 ;
21065 PyObject *swig_obj[1] ;
21066
21067 if (!args) SWIG_fail;
21068 swig_obj[0] = args;
21069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21070 if (!SWIG_IsOK(res1)) {
21071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21072 }
21073 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21074 result = (int) ((arg1)->m_y);
21075 resultobj = SWIG_From_int(static_cast< int >(result));
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21083 PyObject *resultobj = 0;
21084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21085 bool arg2 ;
21086 void *argp1 = 0 ;
21087 int res1 = 0 ;
21088 bool val2 ;
21089 int ecode2 = 0 ;
21090 PyObject *swig_obj[2] ;
21091
21092 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21096 }
21097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21098 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21099 if (!SWIG_IsOK(ecode2)) {
21100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21101 }
21102 arg2 = static_cast< bool >(val2);
21103 if (arg1) (arg1)->m_leftDown = arg2;
21104
21105 resultobj = SWIG_Py_Void();
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21113 PyObject *resultobj = 0;
21114 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21115 bool result;
21116 void *argp1 = 0 ;
21117 int res1 = 0 ;
21118 PyObject *swig_obj[1] ;
21119
21120 if (!args) SWIG_fail;
21121 swig_obj[0] = args;
21122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21125 }
21126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21127 result = (bool) ((arg1)->m_leftDown);
21128 {
21129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21130 }
21131 return resultobj;
21132 fail:
21133 return NULL;
21134 }
21135
21136
21137 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21138 PyObject *resultobj = 0;
21139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21140 bool arg2 ;
21141 void *argp1 = 0 ;
21142 int res1 = 0 ;
21143 bool val2 ;
21144 int ecode2 = 0 ;
21145 PyObject *swig_obj[2] ;
21146
21147 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21149 if (!SWIG_IsOK(res1)) {
21150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21151 }
21152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21153 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21154 if (!SWIG_IsOK(ecode2)) {
21155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21156 }
21157 arg2 = static_cast< bool >(val2);
21158 if (arg1) (arg1)->m_middleDown = arg2;
21159
21160 resultobj = SWIG_Py_Void();
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21168 PyObject *resultobj = 0;
21169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21170 bool result;
21171 void *argp1 = 0 ;
21172 int res1 = 0 ;
21173 PyObject *swig_obj[1] ;
21174
21175 if (!args) SWIG_fail;
21176 swig_obj[0] = args;
21177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21180 }
21181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21182 result = (bool) ((arg1)->m_middleDown);
21183 {
21184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21185 }
21186 return resultobj;
21187 fail:
21188 return NULL;
21189 }
21190
21191
21192 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21193 PyObject *resultobj = 0;
21194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21195 bool arg2 ;
21196 void *argp1 = 0 ;
21197 int res1 = 0 ;
21198 bool val2 ;
21199 int ecode2 = 0 ;
21200 PyObject *swig_obj[2] ;
21201
21202 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21204 if (!SWIG_IsOK(res1)) {
21205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21206 }
21207 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21208 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21209 if (!SWIG_IsOK(ecode2)) {
21210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21211 }
21212 arg2 = static_cast< bool >(val2);
21213 if (arg1) (arg1)->m_rightDown = arg2;
21214
21215 resultobj = SWIG_Py_Void();
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21223 PyObject *resultobj = 0;
21224 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21225 bool result;
21226 void *argp1 = 0 ;
21227 int res1 = 0 ;
21228 PyObject *swig_obj[1] ;
21229
21230 if (!args) SWIG_fail;
21231 swig_obj[0] = args;
21232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21233 if (!SWIG_IsOK(res1)) {
21234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21235 }
21236 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21237 result = (bool) ((arg1)->m_rightDown);
21238 {
21239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21240 }
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21248 PyObject *resultobj = 0;
21249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21250 bool arg2 ;
21251 void *argp1 = 0 ;
21252 int res1 = 0 ;
21253 bool val2 ;
21254 int ecode2 = 0 ;
21255 PyObject *swig_obj[2] ;
21256
21257 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21259 if (!SWIG_IsOK(res1)) {
21260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21261 }
21262 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21263 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21264 if (!SWIG_IsOK(ecode2)) {
21265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21266 }
21267 arg2 = static_cast< bool >(val2);
21268 if (arg1) (arg1)->m_controlDown = arg2;
21269
21270 resultobj = SWIG_Py_Void();
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21278 PyObject *resultobj = 0;
21279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21280 bool result;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 PyObject *swig_obj[1] ;
21284
21285 if (!args) SWIG_fail;
21286 swig_obj[0] = args;
21287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21290 }
21291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21292 result = (bool) ((arg1)->m_controlDown);
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_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21303 PyObject *resultobj = 0;
21304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21305 bool arg2 ;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 bool val2 ;
21309 int ecode2 = 0 ;
21310 PyObject *swig_obj[2] ;
21311
21312 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21314 if (!SWIG_IsOK(res1)) {
21315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21316 }
21317 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21318 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21319 if (!SWIG_IsOK(ecode2)) {
21320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21321 }
21322 arg2 = static_cast< bool >(val2);
21323 if (arg1) (arg1)->m_shiftDown = arg2;
21324
21325 resultobj = SWIG_Py_Void();
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(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_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21345 }
21346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21347 result = (bool) ((arg1)->m_shiftDown);
21348 {
21349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21350 }
21351 return resultobj;
21352 fail:
21353 return NULL;
21354 }
21355
21356
21357 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21358 PyObject *resultobj = 0;
21359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21360 bool arg2 ;
21361 void *argp1 = 0 ;
21362 int res1 = 0 ;
21363 bool val2 ;
21364 int ecode2 = 0 ;
21365 PyObject *swig_obj[2] ;
21366
21367 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21369 if (!SWIG_IsOK(res1)) {
21370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21371 }
21372 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21373 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21374 if (!SWIG_IsOK(ecode2)) {
21375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21376 }
21377 arg2 = static_cast< bool >(val2);
21378 if (arg1) (arg1)->m_altDown = arg2;
21379
21380 resultobj = SWIG_Py_Void();
21381 return resultobj;
21382 fail:
21383 return NULL;
21384 }
21385
21386
21387 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21388 PyObject *resultobj = 0;
21389 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21390 bool result;
21391 void *argp1 = 0 ;
21392 int res1 = 0 ;
21393 PyObject *swig_obj[1] ;
21394
21395 if (!args) SWIG_fail;
21396 swig_obj[0] = args;
21397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21398 if (!SWIG_IsOK(res1)) {
21399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21400 }
21401 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21402 result = (bool) ((arg1)->m_altDown);
21403 {
21404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21405 }
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21413 PyObject *resultobj = 0;
21414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21415 bool arg2 ;
21416 void *argp1 = 0 ;
21417 int res1 = 0 ;
21418 bool val2 ;
21419 int ecode2 = 0 ;
21420 PyObject *swig_obj[2] ;
21421
21422 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21424 if (!SWIG_IsOK(res1)) {
21425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21426 }
21427 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21428 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21429 if (!SWIG_IsOK(ecode2)) {
21430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21431 }
21432 arg2 = static_cast< bool >(val2);
21433 if (arg1) (arg1)->m_metaDown = arg2;
21434
21435 resultobj = SWIG_Py_Void();
21436 return resultobj;
21437 fail:
21438 return NULL;
21439 }
21440
21441
21442 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21443 PyObject *resultobj = 0;
21444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21445 bool result;
21446 void *argp1 = 0 ;
21447 int res1 = 0 ;
21448 PyObject *swig_obj[1] ;
21449
21450 if (!args) SWIG_fail;
21451 swig_obj[0] = args;
21452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21453 if (!SWIG_IsOK(res1)) {
21454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21455 }
21456 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21457 result = (bool) ((arg1)->m_metaDown);
21458 {
21459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21460 }
21461 return resultobj;
21462 fail:
21463 return NULL;
21464 }
21465
21466
21467 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21468 PyObject *resultobj = 0;
21469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21470 int arg2 ;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 int val2 ;
21474 int ecode2 = 0 ;
21475 PyObject *swig_obj[2] ;
21476
21477 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21479 if (!SWIG_IsOK(res1)) {
21480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21481 }
21482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21483 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21484 if (!SWIG_IsOK(ecode2)) {
21485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21486 }
21487 arg2 = static_cast< int >(val2);
21488 if (arg1) (arg1)->m_wheelRotation = arg2;
21489
21490 resultobj = SWIG_Py_Void();
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21498 PyObject *resultobj = 0;
21499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21500 int result;
21501 void *argp1 = 0 ;
21502 int res1 = 0 ;
21503 PyObject *swig_obj[1] ;
21504
21505 if (!args) SWIG_fail;
21506 swig_obj[0] = args;
21507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21508 if (!SWIG_IsOK(res1)) {
21509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21510 }
21511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21512 result = (int) ((arg1)->m_wheelRotation);
21513 resultobj = SWIG_From_int(static_cast< int >(result));
21514 return resultobj;
21515 fail:
21516 return NULL;
21517 }
21518
21519
21520 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21521 PyObject *resultobj = 0;
21522 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21523 int arg2 ;
21524 void *argp1 = 0 ;
21525 int res1 = 0 ;
21526 int val2 ;
21527 int ecode2 = 0 ;
21528 PyObject *swig_obj[2] ;
21529
21530 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21532 if (!SWIG_IsOK(res1)) {
21533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21534 }
21535 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21536 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21537 if (!SWIG_IsOK(ecode2)) {
21538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21539 }
21540 arg2 = static_cast< int >(val2);
21541 if (arg1) (arg1)->m_wheelDelta = arg2;
21542
21543 resultobj = SWIG_Py_Void();
21544 return resultobj;
21545 fail:
21546 return NULL;
21547 }
21548
21549
21550 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21551 PyObject *resultobj = 0;
21552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21553 int result;
21554 void *argp1 = 0 ;
21555 int res1 = 0 ;
21556 PyObject *swig_obj[1] ;
21557
21558 if (!args) SWIG_fail;
21559 swig_obj[0] = args;
21560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21561 if (!SWIG_IsOK(res1)) {
21562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21563 }
21564 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21565 result = (int) ((arg1)->m_wheelDelta);
21566 resultobj = SWIG_From_int(static_cast< int >(result));
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21576 int arg2 ;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 int val2 ;
21580 int ecode2 = 0 ;
21581 PyObject *swig_obj[2] ;
21582
21583 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21585 if (!SWIG_IsOK(res1)) {
21586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21587 }
21588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21589 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21590 if (!SWIG_IsOK(ecode2)) {
21591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21592 }
21593 arg2 = static_cast< int >(val2);
21594 if (arg1) (arg1)->m_linesPerAction = arg2;
21595
21596 resultobj = SWIG_Py_Void();
21597 return resultobj;
21598 fail:
21599 return NULL;
21600 }
21601
21602
21603 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21604 PyObject *resultobj = 0;
21605 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21606 int result;
21607 void *argp1 = 0 ;
21608 int res1 = 0 ;
21609 PyObject *swig_obj[1] ;
21610
21611 if (!args) SWIG_fail;
21612 swig_obj[0] = args;
21613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21614 if (!SWIG_IsOK(res1)) {
21615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21616 }
21617 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21618 result = (int) ((arg1)->m_linesPerAction);
21619 resultobj = SWIG_From_int(static_cast< int >(result));
21620 return resultobj;
21621 fail:
21622 return NULL;
21623 }
21624
21625
21626 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21627 PyObject *obj;
21628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21629 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21630 return SWIG_Py_Void();
21631 }
21632
21633 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21634 return SWIG_Python_InitShadowInstance(args);
21635 }
21636
21637 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21638 PyObject *resultobj = 0;
21639 int arg1 = (int) 0 ;
21640 int arg2 = (int) 0 ;
21641 wxSetCursorEvent *result = 0 ;
21642 int val1 ;
21643 int ecode1 = 0 ;
21644 int val2 ;
21645 int ecode2 = 0 ;
21646 PyObject * obj0 = 0 ;
21647 PyObject * obj1 = 0 ;
21648 char * kwnames[] = {
21649 (char *) "x",(char *) "y", NULL
21650 };
21651
21652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21653 if (obj0) {
21654 ecode1 = SWIG_AsVal_int(obj0, &val1);
21655 if (!SWIG_IsOK(ecode1)) {
21656 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21657 }
21658 arg1 = static_cast< int >(val1);
21659 }
21660 if (obj1) {
21661 ecode2 = SWIG_AsVal_int(obj1, &val2);
21662 if (!SWIG_IsOK(ecode2)) {
21663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21664 }
21665 arg2 = static_cast< int >(val2);
21666 }
21667 {
21668 PyThreadState* __tstate = wxPyBeginAllowThreads();
21669 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21670 wxPyEndAllowThreads(__tstate);
21671 if (PyErr_Occurred()) SWIG_fail;
21672 }
21673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21674 return resultobj;
21675 fail:
21676 return NULL;
21677 }
21678
21679
21680 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21681 PyObject *resultobj = 0;
21682 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21683 int result;
21684 void *argp1 = 0 ;
21685 int res1 = 0 ;
21686 PyObject *swig_obj[1] ;
21687
21688 if (!args) SWIG_fail;
21689 swig_obj[0] = args;
21690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21691 if (!SWIG_IsOK(res1)) {
21692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21693 }
21694 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21695 {
21696 PyThreadState* __tstate = wxPyBeginAllowThreads();
21697 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 resultobj = SWIG_From_int(static_cast< int >(result));
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21709 PyObject *resultobj = 0;
21710 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21711 int result;
21712 void *argp1 = 0 ;
21713 int res1 = 0 ;
21714 PyObject *swig_obj[1] ;
21715
21716 if (!args) SWIG_fail;
21717 swig_obj[0] = args;
21718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21719 if (!SWIG_IsOK(res1)) {
21720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21721 }
21722 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21726 wxPyEndAllowThreads(__tstate);
21727 if (PyErr_Occurred()) SWIG_fail;
21728 }
21729 resultobj = SWIG_From_int(static_cast< int >(result));
21730 return resultobj;
21731 fail:
21732 return NULL;
21733 }
21734
21735
21736 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21739 wxCursor *arg2 = 0 ;
21740 void *argp1 = 0 ;
21741 int res1 = 0 ;
21742 void *argp2 = 0 ;
21743 int res2 = 0 ;
21744 PyObject * obj0 = 0 ;
21745 PyObject * obj1 = 0 ;
21746 char * kwnames[] = {
21747 (char *) "self",(char *) "cursor", NULL
21748 };
21749
21750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21752 if (!SWIG_IsOK(res1)) {
21753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21754 }
21755 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21756 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21757 if (!SWIG_IsOK(res2)) {
21758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21759 }
21760 if (!argp2) {
21761 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21762 }
21763 arg2 = reinterpret_cast< wxCursor * >(argp2);
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 (arg1)->SetCursor((wxCursor const &)*arg2);
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_Py_Void();
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *resultobj = 0;
21779 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21780 wxCursor *result = 0 ;
21781 void *argp1 = 0 ;
21782 int res1 = 0 ;
21783 PyObject *swig_obj[1] ;
21784
21785 if (!args) SWIG_fail;
21786 swig_obj[0] = args;
21787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21788 if (!SWIG_IsOK(res1)) {
21789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21790 }
21791 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 {
21795 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21796 result = (wxCursor *) &_result_ref;
21797 }
21798 wxPyEndAllowThreads(__tstate);
21799 if (PyErr_Occurred()) SWIG_fail;
21800 }
21801 {
21802 wxCursor* resultptr = new wxCursor(*result);
21803 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21804 }
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21812 PyObject *resultobj = 0;
21813 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21814 bool result;
21815 void *argp1 = 0 ;
21816 int res1 = 0 ;
21817 PyObject *swig_obj[1] ;
21818
21819 if (!args) SWIG_fail;
21820 swig_obj[0] = args;
21821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21824 }
21825 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21829 wxPyEndAllowThreads(__tstate);
21830 if (PyErr_Occurred()) SWIG_fail;
21831 }
21832 {
21833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21834 }
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21842 PyObject *obj;
21843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21844 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21845 return SWIG_Py_Void();
21846 }
21847
21848 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 return SWIG_Python_InitShadowInstance(args);
21850 }
21851
21852 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj = 0;
21854 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21855 wxKeyEvent *result = 0 ;
21856 int val1 ;
21857 int ecode1 = 0 ;
21858 PyObject * obj0 = 0 ;
21859 char * kwnames[] = {
21860 (char *) "eventType", NULL
21861 };
21862
21863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21864 if (obj0) {
21865 ecode1 = SWIG_AsVal_int(obj0, &val1);
21866 if (!SWIG_IsOK(ecode1)) {
21867 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21868 }
21869 arg1 = static_cast< wxEventType >(val1);
21870 }
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21874 wxPyEndAllowThreads(__tstate);
21875 if (PyErr_Occurred()) SWIG_fail;
21876 }
21877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21878 return resultobj;
21879 fail:
21880 return NULL;
21881 }
21882
21883
21884 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21885 PyObject *resultobj = 0;
21886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21887 int result;
21888 void *argp1 = 0 ;
21889 int res1 = 0 ;
21890 PyObject *swig_obj[1] ;
21891
21892 if (!args) SWIG_fail;
21893 swig_obj[0] = args;
21894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21895 if (!SWIG_IsOK(res1)) {
21896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21897 }
21898 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21899 {
21900 PyThreadState* __tstate = wxPyBeginAllowThreads();
21901 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 resultobj = SWIG_From_int(static_cast< int >(result));
21906 return resultobj;
21907 fail:
21908 return NULL;
21909 }
21910
21911
21912 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21913 PyObject *resultobj = 0;
21914 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21915 bool result;
21916 void *argp1 = 0 ;
21917 int res1 = 0 ;
21918 PyObject *swig_obj[1] ;
21919
21920 if (!args) SWIG_fail;
21921 swig_obj[0] = args;
21922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21923 if (!SWIG_IsOK(res1)) {
21924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21925 }
21926 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21927 {
21928 PyThreadState* __tstate = wxPyBeginAllowThreads();
21929 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21935 }
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21943 PyObject *resultobj = 0;
21944 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21945 bool 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_wxKeyEvent, 0 | 0 );
21953 if (!SWIG_IsOK(res1)) {
21954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21955 }
21956 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21957 {
21958 PyThreadState* __tstate = wxPyBeginAllowThreads();
21959 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21973 PyObject *resultobj = 0;
21974 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21975 bool result;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 PyObject *swig_obj[1] ;
21979
21980 if (!args) SWIG_fail;
21981 swig_obj[0] = args;
21982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21985 }
21986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22005 bool result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 {
22024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22033 PyObject *resultobj = 0;
22034 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22035 bool result;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 PyObject *swig_obj[1] ;
22039
22040 if (!args) SWIG_fail;
22041 swig_obj[0] = args;
22042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22045 }
22046 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 {
22054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22055 }
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22063 PyObject *resultobj = 0;
22064 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22065 bool result;
22066 void *argp1 = 0 ;
22067 int res1 = 0 ;
22068 PyObject *swig_obj[1] ;
22069
22070 if (!args) SWIG_fail;
22071 swig_obj[0] = args;
22072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22073 if (!SWIG_IsOK(res1)) {
22074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22075 }
22076 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 {
22084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22085 }
22086 return resultobj;
22087 fail:
22088 return NULL;
22089 }
22090
22091
22092 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22093 PyObject *resultobj = 0;
22094 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22095 int result;
22096 void *argp1 = 0 ;
22097 int res1 = 0 ;
22098 PyObject *swig_obj[1] ;
22099
22100 if (!args) SWIG_fail;
22101 swig_obj[0] = args;
22102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22103 if (!SWIG_IsOK(res1)) {
22104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22105 }
22106 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 resultobj = SWIG_From_int(static_cast< int >(result));
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22121 PyObject *resultobj = 0;
22122 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22123 int result;
22124 void *argp1 = 0 ;
22125 int res1 = 0 ;
22126 PyObject *swig_obj[1] ;
22127
22128 if (!args) SWIG_fail;
22129 swig_obj[0] = args;
22130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22131 if (!SWIG_IsOK(res1)) {
22132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22133 }
22134 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 resultobj = SWIG_From_int(static_cast< int >(result));
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22149 PyObject *resultobj = 0;
22150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22151 unsigned int result;
22152 void *argp1 = 0 ;
22153 int res1 = 0 ;
22154 PyObject *swig_obj[1] ;
22155
22156 if (!args) SWIG_fail;
22157 swig_obj[0] = args;
22158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22161 }
22162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22177 PyObject *resultobj = 0;
22178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22179 unsigned int result;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 PyObject *swig_obj[1] ;
22183
22184 if (!args) SWIG_fail;
22185 swig_obj[0] = args;
22186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22187 if (!SWIG_IsOK(res1)) {
22188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22189 }
22190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22198 return resultobj;
22199 fail:
22200 return NULL;
22201 }
22202
22203
22204 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22205 PyObject *resultobj = 0;
22206 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22207 wxPoint result;
22208 void *argp1 = 0 ;
22209 int res1 = 0 ;
22210 PyObject *swig_obj[1] ;
22211
22212 if (!args) SWIG_fail;
22213 swig_obj[0] = args;
22214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22215 if (!SWIG_IsOK(res1)) {
22216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22217 }
22218 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = (arg1)->GetPosition();
22222 wxPyEndAllowThreads(__tstate);
22223 if (PyErr_Occurred()) SWIG_fail;
22224 }
22225 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22226 return resultobj;
22227 fail:
22228 return NULL;
22229 }
22230
22231
22232 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22233 PyObject *resultobj = 0;
22234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22235 long *arg2 = (long *) 0 ;
22236 long *arg3 = (long *) 0 ;
22237 void *argp1 = 0 ;
22238 int res1 = 0 ;
22239 long temp2 ;
22240 int res2 = SWIG_TMPOBJ ;
22241 long temp3 ;
22242 int res3 = SWIG_TMPOBJ ;
22243 PyObject *swig_obj[1] ;
22244
22245 arg2 = &temp2;
22246 arg3 = &temp3;
22247 if (!args) SWIG_fail;
22248 swig_obj[0] = args;
22249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22250 if (!SWIG_IsOK(res1)) {
22251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22252 }
22253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22254 {
22255 PyThreadState* __tstate = wxPyBeginAllowThreads();
22256 (arg1)->GetPosition(arg2,arg3);
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 resultobj = SWIG_Py_Void();
22261 if (SWIG_IsTmpObj(res2)) {
22262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22263 } else {
22264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22266 }
22267 if (SWIG_IsTmpObj(res3)) {
22268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22269 } else {
22270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22272 }
22273 return resultobj;
22274 fail:
22275 return NULL;
22276 }
22277
22278
22279 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22280 PyObject *resultobj = 0;
22281 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22282 int result;
22283 void *argp1 = 0 ;
22284 int res1 = 0 ;
22285 PyObject *swig_obj[1] ;
22286
22287 if (!args) SWIG_fail;
22288 swig_obj[0] = args;
22289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22290 if (!SWIG_IsOK(res1)) {
22291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22292 }
22293 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (int)((wxKeyEvent const *)arg1)->GetX();
22297 wxPyEndAllowThreads(__tstate);
22298 if (PyErr_Occurred()) SWIG_fail;
22299 }
22300 resultobj = SWIG_From_int(static_cast< int >(result));
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22308 PyObject *resultobj = 0;
22309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22310 int result;
22311 void *argp1 = 0 ;
22312 int res1 = 0 ;
22313 PyObject *swig_obj[1] ;
22314
22315 if (!args) SWIG_fail;
22316 swig_obj[0] = args;
22317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22318 if (!SWIG_IsOK(res1)) {
22319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22320 }
22321 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22322 {
22323 PyThreadState* __tstate = wxPyBeginAllowThreads();
22324 result = (int)((wxKeyEvent const *)arg1)->GetY();
22325 wxPyEndAllowThreads(__tstate);
22326 if (PyErr_Occurred()) SWIG_fail;
22327 }
22328 resultobj = SWIG_From_int(static_cast< int >(result));
22329 return resultobj;
22330 fail:
22331 return NULL;
22332 }
22333
22334
22335 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22336 PyObject *resultobj = 0;
22337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22338 int arg2 ;
22339 void *argp1 = 0 ;
22340 int res1 = 0 ;
22341 int val2 ;
22342 int ecode2 = 0 ;
22343 PyObject *swig_obj[2] ;
22344
22345 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22347 if (!SWIG_IsOK(res1)) {
22348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22349 }
22350 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22351 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22352 if (!SWIG_IsOK(ecode2)) {
22353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22354 }
22355 arg2 = static_cast< int >(val2);
22356 if (arg1) (arg1)->m_x = arg2;
22357
22358 resultobj = SWIG_Py_Void();
22359 return resultobj;
22360 fail:
22361 return NULL;
22362 }
22363
22364
22365 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22366 PyObject *resultobj = 0;
22367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22368 int result;
22369 void *argp1 = 0 ;
22370 int res1 = 0 ;
22371 PyObject *swig_obj[1] ;
22372
22373 if (!args) SWIG_fail;
22374 swig_obj[0] = args;
22375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22376 if (!SWIG_IsOK(res1)) {
22377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22378 }
22379 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22380 result = (int) ((arg1)->m_x);
22381 resultobj = SWIG_From_int(static_cast< int >(result));
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22389 PyObject *resultobj = 0;
22390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22391 int arg2 ;
22392 void *argp1 = 0 ;
22393 int res1 = 0 ;
22394 int val2 ;
22395 int ecode2 = 0 ;
22396 PyObject *swig_obj[2] ;
22397
22398 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22402 }
22403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22404 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22405 if (!SWIG_IsOK(ecode2)) {
22406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22407 }
22408 arg2 = static_cast< int >(val2);
22409 if (arg1) (arg1)->m_y = arg2;
22410
22411 resultobj = SWIG_Py_Void();
22412 return resultobj;
22413 fail:
22414 return NULL;
22415 }
22416
22417
22418 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22419 PyObject *resultobj = 0;
22420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22421 int result;
22422 void *argp1 = 0 ;
22423 int res1 = 0 ;
22424 PyObject *swig_obj[1] ;
22425
22426 if (!args) SWIG_fail;
22427 swig_obj[0] = args;
22428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22429 if (!SWIG_IsOK(res1)) {
22430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22431 }
22432 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22433 result = (int) ((arg1)->m_y);
22434 resultobj = SWIG_From_int(static_cast< int >(result));
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22442 PyObject *resultobj = 0;
22443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22444 long arg2 ;
22445 void *argp1 = 0 ;
22446 int res1 = 0 ;
22447 long val2 ;
22448 int ecode2 = 0 ;
22449 PyObject *swig_obj[2] ;
22450
22451 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22453 if (!SWIG_IsOK(res1)) {
22454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22455 }
22456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22457 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22458 if (!SWIG_IsOK(ecode2)) {
22459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22460 }
22461 arg2 = static_cast< long >(val2);
22462 if (arg1) (arg1)->m_keyCode = arg2;
22463
22464 resultobj = SWIG_Py_Void();
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *resultobj = 0;
22473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22474 long result;
22475 void *argp1 = 0 ;
22476 int res1 = 0 ;
22477 PyObject *swig_obj[1] ;
22478
22479 if (!args) SWIG_fail;
22480 swig_obj[0] = args;
22481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22484 }
22485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22486 result = (long) ((arg1)->m_keyCode);
22487 resultobj = SWIG_From_long(static_cast< long >(result));
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22497 bool arg2 ;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 bool val2 ;
22501 int ecode2 = 0 ;
22502 PyObject *swig_obj[2] ;
22503
22504 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22506 if (!SWIG_IsOK(res1)) {
22507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22508 }
22509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22510 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22511 if (!SWIG_IsOK(ecode2)) {
22512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22513 }
22514 arg2 = static_cast< bool >(val2);
22515 if (arg1) (arg1)->m_controlDown = arg2;
22516
22517 resultobj = SWIG_Py_Void();
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22527 bool result;
22528 void *argp1 = 0 ;
22529 int res1 = 0 ;
22530 PyObject *swig_obj[1] ;
22531
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22537 }
22538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22539 result = (bool) ((arg1)->m_controlDown);
22540 {
22541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22542 }
22543 return resultobj;
22544 fail:
22545 return NULL;
22546 }
22547
22548
22549 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22550 PyObject *resultobj = 0;
22551 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22552 bool arg2 ;
22553 void *argp1 = 0 ;
22554 int res1 = 0 ;
22555 bool val2 ;
22556 int ecode2 = 0 ;
22557 PyObject *swig_obj[2] ;
22558
22559 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22561 if (!SWIG_IsOK(res1)) {
22562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22563 }
22564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22565 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22566 if (!SWIG_IsOK(ecode2)) {
22567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22568 }
22569 arg2 = static_cast< bool >(val2);
22570 if (arg1) (arg1)->m_shiftDown = arg2;
22571
22572 resultobj = SWIG_Py_Void();
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22582 bool result;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 PyObject *swig_obj[1] ;
22586
22587 if (!args) SWIG_fail;
22588 swig_obj[0] = args;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22592 }
22593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22594 result = (bool) ((arg1)->m_shiftDown);
22595 {
22596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22597 }
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22605 PyObject *resultobj = 0;
22606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22607 bool arg2 ;
22608 void *argp1 = 0 ;
22609 int res1 = 0 ;
22610 bool val2 ;
22611 int ecode2 = 0 ;
22612 PyObject *swig_obj[2] ;
22613
22614 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22616 if (!SWIG_IsOK(res1)) {
22617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22618 }
22619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22620 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22621 if (!SWIG_IsOK(ecode2)) {
22622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22623 }
22624 arg2 = static_cast< bool >(val2);
22625 if (arg1) (arg1)->m_altDown = arg2;
22626
22627 resultobj = SWIG_Py_Void();
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22635 PyObject *resultobj = 0;
22636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22637 bool result;
22638 void *argp1 = 0 ;
22639 int res1 = 0 ;
22640 PyObject *swig_obj[1] ;
22641
22642 if (!args) SWIG_fail;
22643 swig_obj[0] = args;
22644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22645 if (!SWIG_IsOK(res1)) {
22646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22647 }
22648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22649 result = (bool) ((arg1)->m_altDown);
22650 {
22651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22652 }
22653 return resultobj;
22654 fail:
22655 return NULL;
22656 }
22657
22658
22659 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22660 PyObject *resultobj = 0;
22661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22662 bool arg2 ;
22663 void *argp1 = 0 ;
22664 int res1 = 0 ;
22665 bool val2 ;
22666 int ecode2 = 0 ;
22667 PyObject *swig_obj[2] ;
22668
22669 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22671 if (!SWIG_IsOK(res1)) {
22672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22673 }
22674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22675 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22676 if (!SWIG_IsOK(ecode2)) {
22677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22678 }
22679 arg2 = static_cast< bool >(val2);
22680 if (arg1) (arg1)->m_metaDown = arg2;
22681
22682 resultobj = SWIG_Py_Void();
22683 return resultobj;
22684 fail:
22685 return NULL;
22686 }
22687
22688
22689 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22690 PyObject *resultobj = 0;
22691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22692 bool result;
22693 void *argp1 = 0 ;
22694 int res1 = 0 ;
22695 PyObject *swig_obj[1] ;
22696
22697 if (!args) SWIG_fail;
22698 swig_obj[0] = args;
22699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22700 if (!SWIG_IsOK(res1)) {
22701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22702 }
22703 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22704 result = (bool) ((arg1)->m_metaDown);
22705 {
22706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22707 }
22708 return resultobj;
22709 fail:
22710 return NULL;
22711 }
22712
22713
22714 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 PyObject *resultobj = 0;
22716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22717 bool arg2 ;
22718 void *argp1 = 0 ;
22719 int res1 = 0 ;
22720 bool val2 ;
22721 int ecode2 = 0 ;
22722 PyObject *swig_obj[2] ;
22723
22724 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22726 if (!SWIG_IsOK(res1)) {
22727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22728 }
22729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22730 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22731 if (!SWIG_IsOK(ecode2)) {
22732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22733 }
22734 arg2 = static_cast< bool >(val2);
22735 if (arg1) (arg1)->m_scanCode = arg2;
22736
22737 resultobj = SWIG_Py_Void();
22738 return resultobj;
22739 fail:
22740 return NULL;
22741 }
22742
22743
22744 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22745 PyObject *resultobj = 0;
22746 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22747 bool result;
22748 void *argp1 = 0 ;
22749 int res1 = 0 ;
22750 PyObject *swig_obj[1] ;
22751
22752 if (!args) SWIG_fail;
22753 swig_obj[0] = args;
22754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22755 if (!SWIG_IsOK(res1)) {
22756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22757 }
22758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22759 result = (bool) ((arg1)->m_scanCode);
22760 {
22761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22762 }
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *resultobj = 0;
22771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22772 unsigned int arg2 ;
22773 void *argp1 = 0 ;
22774 int res1 = 0 ;
22775 unsigned int val2 ;
22776 int ecode2 = 0 ;
22777 PyObject *swig_obj[2] ;
22778
22779 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22781 if (!SWIG_IsOK(res1)) {
22782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22783 }
22784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22785 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22786 if (!SWIG_IsOK(ecode2)) {
22787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22788 }
22789 arg2 = static_cast< unsigned int >(val2);
22790 if (arg1) (arg1)->m_rawCode = arg2;
22791
22792 resultobj = SWIG_Py_Void();
22793 return resultobj;
22794 fail:
22795 return NULL;
22796 }
22797
22798
22799 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22800 PyObject *resultobj = 0;
22801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22802 unsigned int result;
22803 void *argp1 = 0 ;
22804 int res1 = 0 ;
22805 PyObject *swig_obj[1] ;
22806
22807 if (!args) SWIG_fail;
22808 swig_obj[0] = args;
22809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22810 if (!SWIG_IsOK(res1)) {
22811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22812 }
22813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22814 result = (unsigned int) ((arg1)->m_rawCode);
22815 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22823 PyObject *resultobj = 0;
22824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22825 unsigned int arg2 ;
22826 void *argp1 = 0 ;
22827 int res1 = 0 ;
22828 unsigned int val2 ;
22829 int ecode2 = 0 ;
22830 PyObject *swig_obj[2] ;
22831
22832 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22834 if (!SWIG_IsOK(res1)) {
22835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22836 }
22837 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22838 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22839 if (!SWIG_IsOK(ecode2)) {
22840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22841 }
22842 arg2 = static_cast< unsigned int >(val2);
22843 if (arg1) (arg1)->m_rawFlags = arg2;
22844
22845 resultobj = SWIG_Py_Void();
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22853 PyObject *resultobj = 0;
22854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22855 unsigned int result;
22856 void *argp1 = 0 ;
22857 int res1 = 0 ;
22858 PyObject *swig_obj[1] ;
22859
22860 if (!args) SWIG_fail;
22861 swig_obj[0] = args;
22862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22863 if (!SWIG_IsOK(res1)) {
22864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22865 }
22866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22867 result = (unsigned int) ((arg1)->m_rawFlags);
22868 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22869 return resultobj;
22870 fail:
22871 return NULL;
22872 }
22873
22874
22875 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22876 PyObject *obj;
22877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22878 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22879 return SWIG_Py_Void();
22880 }
22881
22882 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22883 return SWIG_Python_InitShadowInstance(args);
22884 }
22885
22886 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22887 PyObject *resultobj = 0;
22888 wxSize const &arg1_defvalue = wxDefaultSize ;
22889 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22890 int arg2 = (int) 0 ;
22891 wxSizeEvent *result = 0 ;
22892 wxSize temp1 ;
22893 int val2 ;
22894 int ecode2 = 0 ;
22895 PyObject * obj0 = 0 ;
22896 PyObject * obj1 = 0 ;
22897 char * kwnames[] = {
22898 (char *) "sz",(char *) "winid", NULL
22899 };
22900
22901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22902 if (obj0) {
22903 {
22904 arg1 = &temp1;
22905 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22906 }
22907 }
22908 if (obj1) {
22909 ecode2 = SWIG_AsVal_int(obj1, &val2);
22910 if (!SWIG_IsOK(ecode2)) {
22911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22912 }
22913 arg2 = static_cast< int >(val2);
22914 }
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22918 wxPyEndAllowThreads(__tstate);
22919 if (PyErr_Occurred()) SWIG_fail;
22920 }
22921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *resultobj = 0;
22930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22931 wxSize result;
22932 void *argp1 = 0 ;
22933 int res1 = 0 ;
22934 PyObject *swig_obj[1] ;
22935
22936 if (!args) SWIG_fail;
22937 swig_obj[0] = args;
22938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22941 }
22942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 result = ((wxSizeEvent const *)arg1)->GetSize();
22946 wxPyEndAllowThreads(__tstate);
22947 if (PyErr_Occurred()) SWIG_fail;
22948 }
22949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22957 PyObject *resultobj = 0;
22958 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22959 wxRect result;
22960 void *argp1 = 0 ;
22961 int res1 = 0 ;
22962 PyObject *swig_obj[1] ;
22963
22964 if (!args) SWIG_fail;
22965 swig_obj[0] = args;
22966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22969 }
22970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 result = ((wxSizeEvent const *)arg1)->GetRect();
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj = 0;
22986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22987 wxRect arg2 ;
22988 void *argp1 = 0 ;
22989 int res1 = 0 ;
22990 void *argp2 ;
22991 int res2 = 0 ;
22992 PyObject * obj0 = 0 ;
22993 PyObject * obj1 = 0 ;
22994 char * kwnames[] = {
22995 (char *) "self",(char *) "rect", NULL
22996 };
22997
22998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23000 if (!SWIG_IsOK(res1)) {
23001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23002 }
23003 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23004 {
23005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23006 if (!SWIG_IsOK(res2)) {
23007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23008 }
23009 if (!argp2) {
23010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23011 } else {
23012 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23013 arg2 = *temp;
23014 if (SWIG_IsNewObj(res2)) delete temp;
23015 }
23016 }
23017 {
23018 PyThreadState* __tstate = wxPyBeginAllowThreads();
23019 (arg1)->SetRect(arg2);
23020 wxPyEndAllowThreads(__tstate);
23021 if (PyErr_Occurred()) SWIG_fail;
23022 }
23023 resultobj = SWIG_Py_Void();
23024 return resultobj;
23025 fail:
23026 return NULL;
23027 }
23028
23029
23030 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23031 PyObject *resultobj = 0;
23032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23033 wxSize arg2 ;
23034 void *argp1 = 0 ;
23035 int res1 = 0 ;
23036 void *argp2 ;
23037 int res2 = 0 ;
23038 PyObject * obj0 = 0 ;
23039 PyObject * obj1 = 0 ;
23040 char * kwnames[] = {
23041 (char *) "self",(char *) "size", NULL
23042 };
23043
23044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23046 if (!SWIG_IsOK(res1)) {
23047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23048 }
23049 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23050 {
23051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23052 if (!SWIG_IsOK(res2)) {
23053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23054 }
23055 if (!argp2) {
23056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23057 } else {
23058 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23059 arg2 = *temp;
23060 if (SWIG_IsNewObj(res2)) delete temp;
23061 }
23062 }
23063 {
23064 PyThreadState* __tstate = wxPyBeginAllowThreads();
23065 wxSizeEvent_SetSize(arg1,arg2);
23066 wxPyEndAllowThreads(__tstate);
23067 if (PyErr_Occurred()) SWIG_fail;
23068 }
23069 resultobj = SWIG_Py_Void();
23070 return resultobj;
23071 fail:
23072 return NULL;
23073 }
23074
23075
23076 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23077 PyObject *resultobj = 0;
23078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23079 wxSize *arg2 = (wxSize *) 0 ;
23080 void *argp1 = 0 ;
23081 int res1 = 0 ;
23082 void *argp2 = 0 ;
23083 int res2 = 0 ;
23084 PyObject *swig_obj[2] ;
23085
23086 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23088 if (!SWIG_IsOK(res1)) {
23089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23090 }
23091 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23093 if (!SWIG_IsOK(res2)) {
23094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23095 }
23096 arg2 = reinterpret_cast< wxSize * >(argp2);
23097 if (arg1) (arg1)->m_size = *arg2;
23098
23099 resultobj = SWIG_Py_Void();
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23107 PyObject *resultobj = 0;
23108 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23109 wxSize *result = 0 ;
23110 void *argp1 = 0 ;
23111 int res1 = 0 ;
23112 PyObject *swig_obj[1] ;
23113
23114 if (!args) SWIG_fail;
23115 swig_obj[0] = args;
23116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23117 if (!SWIG_IsOK(res1)) {
23118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23119 }
23120 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23121 result = (wxSize *)& ((arg1)->m_size);
23122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23123 return resultobj;
23124 fail:
23125 return NULL;
23126 }
23127
23128
23129 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23130 PyObject *resultobj = 0;
23131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23132 wxRect *arg2 = (wxRect *) 0 ;
23133 void *argp1 = 0 ;
23134 int res1 = 0 ;
23135 void *argp2 = 0 ;
23136 int res2 = 0 ;
23137 PyObject *swig_obj[2] ;
23138
23139 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23141 if (!SWIG_IsOK(res1)) {
23142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23143 }
23144 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23146 if (!SWIG_IsOK(res2)) {
23147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23148 }
23149 arg2 = reinterpret_cast< wxRect * >(argp2);
23150 if (arg1) (arg1)->m_rect = *arg2;
23151
23152 resultobj = SWIG_Py_Void();
23153 return resultobj;
23154 fail:
23155 return NULL;
23156 }
23157
23158
23159 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23160 PyObject *resultobj = 0;
23161 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23162 wxRect *result = 0 ;
23163 void *argp1 = 0 ;
23164 int res1 = 0 ;
23165 PyObject *swig_obj[1] ;
23166
23167 if (!args) SWIG_fail;
23168 swig_obj[0] = args;
23169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23170 if (!SWIG_IsOK(res1)) {
23171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23172 }
23173 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23174 result = (wxRect *)& ((arg1)->m_rect);
23175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 PyObject *obj;
23184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23185 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23186 return SWIG_Py_Void();
23187 }
23188
23189 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23190 return SWIG_Python_InitShadowInstance(args);
23191 }
23192
23193 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23194 PyObject *resultobj = 0;
23195 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23196 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23197 int arg2 = (int) 0 ;
23198 wxMoveEvent *result = 0 ;
23199 wxPoint temp1 ;
23200 int val2 ;
23201 int ecode2 = 0 ;
23202 PyObject * obj0 = 0 ;
23203 PyObject * obj1 = 0 ;
23204 char * kwnames[] = {
23205 (char *) "pos",(char *) "winid", NULL
23206 };
23207
23208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23209 if (obj0) {
23210 {
23211 arg1 = &temp1;
23212 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23213 }
23214 }
23215 if (obj1) {
23216 ecode2 = SWIG_AsVal_int(obj1, &val2);
23217 if (!SWIG_IsOK(ecode2)) {
23218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23219 }
23220 arg2 = static_cast< int >(val2);
23221 }
23222 {
23223 PyThreadState* __tstate = wxPyBeginAllowThreads();
23224 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23225 wxPyEndAllowThreads(__tstate);
23226 if (PyErr_Occurred()) SWIG_fail;
23227 }
23228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23229 return resultobj;
23230 fail:
23231 return NULL;
23232 }
23233
23234
23235 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23236 PyObject *resultobj = 0;
23237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23238 wxPoint result;
23239 void *argp1 = 0 ;
23240 int res1 = 0 ;
23241 PyObject *swig_obj[1] ;
23242
23243 if (!args) SWIG_fail;
23244 swig_obj[0] = args;
23245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23246 if (!SWIG_IsOK(res1)) {
23247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23248 }
23249 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23250 {
23251 PyThreadState* __tstate = wxPyBeginAllowThreads();
23252 result = ((wxMoveEvent const *)arg1)->GetPosition();
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23264 PyObject *resultobj = 0;
23265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23266 wxRect result;
23267 void *argp1 = 0 ;
23268 int res1 = 0 ;
23269 PyObject *swig_obj[1] ;
23270
23271 if (!args) SWIG_fail;
23272 swig_obj[0] = args;
23273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23274 if (!SWIG_IsOK(res1)) {
23275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23276 }
23277 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23278 {
23279 PyThreadState* __tstate = wxPyBeginAllowThreads();
23280 result = ((wxMoveEvent const *)arg1)->GetRect();
23281 wxPyEndAllowThreads(__tstate);
23282 if (PyErr_Occurred()) SWIG_fail;
23283 }
23284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23292 PyObject *resultobj = 0;
23293 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23294 wxRect *arg2 = 0 ;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 wxRect temp2 ;
23298 PyObject * obj0 = 0 ;
23299 PyObject * obj1 = 0 ;
23300 char * kwnames[] = {
23301 (char *) "self",(char *) "rect", NULL
23302 };
23303
23304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23306 if (!SWIG_IsOK(res1)) {
23307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23308 }
23309 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23310 {
23311 arg2 = &temp2;
23312 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23313 }
23314 {
23315 PyThreadState* __tstate = wxPyBeginAllowThreads();
23316 (arg1)->SetRect((wxRect const &)*arg2);
23317 wxPyEndAllowThreads(__tstate);
23318 if (PyErr_Occurred()) SWIG_fail;
23319 }
23320 resultobj = SWIG_Py_Void();
23321 return resultobj;
23322 fail:
23323 return NULL;
23324 }
23325
23326
23327 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23328 PyObject *resultobj = 0;
23329 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23330 wxPoint *arg2 = 0 ;
23331 void *argp1 = 0 ;
23332 int res1 = 0 ;
23333 wxPoint temp2 ;
23334 PyObject * obj0 = 0 ;
23335 PyObject * obj1 = 0 ;
23336 char * kwnames[] = {
23337 (char *) "self",(char *) "pos", NULL
23338 };
23339
23340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23344 }
23345 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23346 {
23347 arg2 = &temp2;
23348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23349 }
23350 {
23351 PyThreadState* __tstate = wxPyBeginAllowThreads();
23352 (arg1)->SetPosition((wxPoint const &)*arg2);
23353 wxPyEndAllowThreads(__tstate);
23354 if (PyErr_Occurred()) SWIG_fail;
23355 }
23356 resultobj = SWIG_Py_Void();
23357 return resultobj;
23358 fail:
23359 return NULL;
23360 }
23361
23362
23363 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23364 PyObject *obj;
23365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23367 return SWIG_Py_Void();
23368 }
23369
23370 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23371 return SWIG_Python_InitShadowInstance(args);
23372 }
23373
23374 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23375 PyObject *resultobj = 0;
23376 int arg1 = (int) 0 ;
23377 wxPaintEvent *result = 0 ;
23378 int val1 ;
23379 int ecode1 = 0 ;
23380 PyObject * obj0 = 0 ;
23381 char * kwnames[] = {
23382 (char *) "Id", NULL
23383 };
23384
23385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23386 if (obj0) {
23387 ecode1 = SWIG_AsVal_int(obj0, &val1);
23388 if (!SWIG_IsOK(ecode1)) {
23389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23390 }
23391 arg1 = static_cast< int >(val1);
23392 }
23393 {
23394 PyThreadState* __tstate = wxPyBeginAllowThreads();
23395 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23396 wxPyEndAllowThreads(__tstate);
23397 if (PyErr_Occurred()) SWIG_fail;
23398 }
23399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23407 PyObject *obj;
23408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23410 return SWIG_Py_Void();
23411 }
23412
23413 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23414 return SWIG_Python_InitShadowInstance(args);
23415 }
23416
23417 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23418 PyObject *resultobj = 0;
23419 int arg1 = (int) 0 ;
23420 wxNcPaintEvent *result = 0 ;
23421 int val1 ;
23422 int ecode1 = 0 ;
23423 PyObject * obj0 = 0 ;
23424 char * kwnames[] = {
23425 (char *) "winid", NULL
23426 };
23427
23428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23429 if (obj0) {
23430 ecode1 = SWIG_AsVal_int(obj0, &val1);
23431 if (!SWIG_IsOK(ecode1)) {
23432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23433 }
23434 arg1 = static_cast< int >(val1);
23435 }
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23450 PyObject *obj;
23451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23452 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23453 return SWIG_Py_Void();
23454 }
23455
23456 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 return SWIG_Python_InitShadowInstance(args);
23458 }
23459
23460 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23461 PyObject *resultobj = 0;
23462 int arg1 = (int) 0 ;
23463 wxDC *arg2 = (wxDC *) NULL ;
23464 wxEraseEvent *result = 0 ;
23465 int val1 ;
23466 int ecode1 = 0 ;
23467 void *argp2 = 0 ;
23468 int res2 = 0 ;
23469 PyObject * obj0 = 0 ;
23470 PyObject * obj1 = 0 ;
23471 char * kwnames[] = {
23472 (char *) "Id",(char *) "dc", NULL
23473 };
23474
23475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23476 if (obj0) {
23477 ecode1 = SWIG_AsVal_int(obj0, &val1);
23478 if (!SWIG_IsOK(ecode1)) {
23479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23480 }
23481 arg1 = static_cast< int >(val1);
23482 }
23483 if (obj1) {
23484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23485 if (!SWIG_IsOK(res2)) {
23486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23487 }
23488 arg2 = reinterpret_cast< wxDC * >(argp2);
23489 }
23490 {
23491 PyThreadState* __tstate = wxPyBeginAllowThreads();
23492 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23493 wxPyEndAllowThreads(__tstate);
23494 if (PyErr_Occurred()) SWIG_fail;
23495 }
23496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23504 PyObject *resultobj = 0;
23505 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23506 wxDC *result = 0 ;
23507 void *argp1 = 0 ;
23508 int res1 = 0 ;
23509 PyObject *swig_obj[1] ;
23510
23511 if (!args) SWIG_fail;
23512 swig_obj[0] = args;
23513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23514 if (!SWIG_IsOK(res1)) {
23515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23516 }
23517 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23518 {
23519 PyThreadState* __tstate = wxPyBeginAllowThreads();
23520 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23521 wxPyEndAllowThreads(__tstate);
23522 if (PyErr_Occurred()) SWIG_fail;
23523 }
23524 {
23525 resultobj = wxPyMake_wxObject(result, (bool)0);
23526 }
23527 return resultobj;
23528 fail:
23529 return NULL;
23530 }
23531
23532
23533 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23534 PyObject *obj;
23535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23536 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23537 return SWIG_Py_Void();
23538 }
23539
23540 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23541 return SWIG_Python_InitShadowInstance(args);
23542 }
23543
23544 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj = 0;
23546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23547 int arg2 = (int) 0 ;
23548 wxFocusEvent *result = 0 ;
23549 int val1 ;
23550 int ecode1 = 0 ;
23551 int val2 ;
23552 int ecode2 = 0 ;
23553 PyObject * obj0 = 0 ;
23554 PyObject * obj1 = 0 ;
23555 char * kwnames[] = {
23556 (char *) "type",(char *) "winid", NULL
23557 };
23558
23559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23560 if (obj0) {
23561 ecode1 = SWIG_AsVal_int(obj0, &val1);
23562 if (!SWIG_IsOK(ecode1)) {
23563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23564 }
23565 arg1 = static_cast< wxEventType >(val1);
23566 }
23567 if (obj1) {
23568 ecode2 = SWIG_AsVal_int(obj1, &val2);
23569 if (!SWIG_IsOK(ecode2)) {
23570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23571 }
23572 arg2 = static_cast< int >(val2);
23573 }
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *resultobj = 0;
23589 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23590 wxWindow *result = 0 ;
23591 void *argp1 = 0 ;
23592 int res1 = 0 ;
23593 PyObject *swig_obj[1] ;
23594
23595 if (!args) SWIG_fail;
23596 swig_obj[0] = args;
23597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23598 if (!SWIG_IsOK(res1)) {
23599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23600 }
23601 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = wxPyMake_wxObject(result, (bool)0);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj = 0;
23619 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23620 wxWindow *arg2 = (wxWindow *) 0 ;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 void *argp2 = 0 ;
23624 int res2 = 0 ;
23625 PyObject * obj0 = 0 ;
23626 PyObject * obj1 = 0 ;
23627 char * kwnames[] = {
23628 (char *) "self",(char *) "win", NULL
23629 };
23630
23631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23633 if (!SWIG_IsOK(res1)) {
23634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23635 }
23636 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23638 if (!SWIG_IsOK(res2)) {
23639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23640 }
23641 arg2 = reinterpret_cast< wxWindow * >(argp2);
23642 {
23643 PyThreadState* __tstate = wxPyBeginAllowThreads();
23644 (arg1)->SetWindow(arg2);
23645 wxPyEndAllowThreads(__tstate);
23646 if (PyErr_Occurred()) SWIG_fail;
23647 }
23648 resultobj = SWIG_Py_Void();
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23656 PyObject *obj;
23657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23658 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23659 return SWIG_Py_Void();
23660 }
23661
23662 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23663 return SWIG_Python_InitShadowInstance(args);
23664 }
23665
23666 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23667 PyObject *resultobj = 0;
23668 wxWindow *arg1 = (wxWindow *) NULL ;
23669 wxChildFocusEvent *result = 0 ;
23670 void *argp1 = 0 ;
23671 int res1 = 0 ;
23672 PyObject * obj0 = 0 ;
23673 char * kwnames[] = {
23674 (char *) "win", NULL
23675 };
23676
23677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23678 if (obj0) {
23679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23680 if (!SWIG_IsOK(res1)) {
23681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23682 }
23683 arg1 = reinterpret_cast< wxWindow * >(argp1);
23684 }
23685 {
23686 PyThreadState* __tstate = wxPyBeginAllowThreads();
23687 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23688 wxPyEndAllowThreads(__tstate);
23689 if (PyErr_Occurred()) SWIG_fail;
23690 }
23691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23699 PyObject *resultobj = 0;
23700 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23701 wxWindow *result = 0 ;
23702 void *argp1 = 0 ;
23703 int res1 = 0 ;
23704 PyObject *swig_obj[1] ;
23705
23706 if (!args) SWIG_fail;
23707 swig_obj[0] = args;
23708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23709 if (!SWIG_IsOK(res1)) {
23710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23711 }
23712 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 {
23720 resultobj = wxPyMake_wxObject(result, (bool)0);
23721 }
23722 return resultobj;
23723 fail:
23724 return NULL;
23725 }
23726
23727
23728 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23729 PyObject *obj;
23730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23731 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23732 return SWIG_Py_Void();
23733 }
23734
23735 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 return SWIG_Python_InitShadowInstance(args);
23737 }
23738
23739 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj = 0;
23741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23742 bool arg2 = (bool) true ;
23743 int arg3 = (int) 0 ;
23744 wxActivateEvent *result = 0 ;
23745 int val1 ;
23746 int ecode1 = 0 ;
23747 bool val2 ;
23748 int ecode2 = 0 ;
23749 int val3 ;
23750 int ecode3 = 0 ;
23751 PyObject * obj0 = 0 ;
23752 PyObject * obj1 = 0 ;
23753 PyObject * obj2 = 0 ;
23754 char * kwnames[] = {
23755 (char *) "type",(char *) "active",(char *) "Id", NULL
23756 };
23757
23758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23759 if (obj0) {
23760 ecode1 = SWIG_AsVal_int(obj0, &val1);
23761 if (!SWIG_IsOK(ecode1)) {
23762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23763 }
23764 arg1 = static_cast< wxEventType >(val1);
23765 }
23766 if (obj1) {
23767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23768 if (!SWIG_IsOK(ecode2)) {
23769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23770 }
23771 arg2 = static_cast< bool >(val2);
23772 }
23773 if (obj2) {
23774 ecode3 = SWIG_AsVal_int(obj2, &val3);
23775 if (!SWIG_IsOK(ecode3)) {
23776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23777 }
23778 arg3 = static_cast< int >(val3);
23779 }
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23787 return resultobj;
23788 fail:
23789 return NULL;
23790 }
23791
23792
23793 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23794 PyObject *resultobj = 0;
23795 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23796 bool result;
23797 void *argp1 = 0 ;
23798 int res1 = 0 ;
23799 PyObject *swig_obj[1] ;
23800
23801 if (!args) SWIG_fail;
23802 swig_obj[0] = args;
23803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23804 if (!SWIG_IsOK(res1)) {
23805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23806 }
23807 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23811 wxPyEndAllowThreads(__tstate);
23812 if (PyErr_Occurred()) SWIG_fail;
23813 }
23814 {
23815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23816 }
23817 return resultobj;
23818 fail:
23819 return NULL;
23820 }
23821
23822
23823 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23824 PyObject *obj;
23825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23826 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23827 return SWIG_Py_Void();
23828 }
23829
23830 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23831 return SWIG_Python_InitShadowInstance(args);
23832 }
23833
23834 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23835 PyObject *resultobj = 0;
23836 int arg1 = (int) 0 ;
23837 wxInitDialogEvent *result = 0 ;
23838 int val1 ;
23839 int ecode1 = 0 ;
23840 PyObject * obj0 = 0 ;
23841 char * kwnames[] = {
23842 (char *) "Id", NULL
23843 };
23844
23845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23846 if (obj0) {
23847 ecode1 = SWIG_AsVal_int(obj0, &val1);
23848 if (!SWIG_IsOK(ecode1)) {
23849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23850 }
23851 arg1 = static_cast< int >(val1);
23852 }
23853 {
23854 PyThreadState* __tstate = wxPyBeginAllowThreads();
23855 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23856 wxPyEndAllowThreads(__tstate);
23857 if (PyErr_Occurred()) SWIG_fail;
23858 }
23859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23860 return resultobj;
23861 fail:
23862 return NULL;
23863 }
23864
23865
23866 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23867 PyObject *obj;
23868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23869 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23870 return SWIG_Py_Void();
23871 }
23872
23873 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23874 return SWIG_Python_InitShadowInstance(args);
23875 }
23876
23877 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23878 PyObject *resultobj = 0;
23879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23880 int arg2 = (int) 0 ;
23881 wxMenu *arg3 = (wxMenu *) NULL ;
23882 wxMenuEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 int val2 ;
23886 int ecode2 = 0 ;
23887 void *argp3 = 0 ;
23888 int res3 = 0 ;
23889 PyObject * obj0 = 0 ;
23890 PyObject * obj1 = 0 ;
23891 PyObject * obj2 = 0 ;
23892 char * kwnames[] = {
23893 (char *) "type",(char *) "winid",(char *) "menu", NULL
23894 };
23895
23896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23897 if (obj0) {
23898 ecode1 = SWIG_AsVal_int(obj0, &val1);
23899 if (!SWIG_IsOK(ecode1)) {
23900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23901 }
23902 arg1 = static_cast< wxEventType >(val1);
23903 }
23904 if (obj1) {
23905 ecode2 = SWIG_AsVal_int(obj1, &val2);
23906 if (!SWIG_IsOK(ecode2)) {
23907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23908 }
23909 arg2 = static_cast< int >(val2);
23910 }
23911 if (obj2) {
23912 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23913 if (!SWIG_IsOK(res3)) {
23914 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23915 }
23916 arg3 = reinterpret_cast< wxMenu * >(argp3);
23917 }
23918 {
23919 PyThreadState* __tstate = wxPyBeginAllowThreads();
23920 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23921 wxPyEndAllowThreads(__tstate);
23922 if (PyErr_Occurred()) SWIG_fail;
23923 }
23924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23925 return resultobj;
23926 fail:
23927 return NULL;
23928 }
23929
23930
23931 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23932 PyObject *resultobj = 0;
23933 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23934 int result;
23935 void *argp1 = 0 ;
23936 int res1 = 0 ;
23937 PyObject *swig_obj[1] ;
23938
23939 if (!args) SWIG_fail;
23940 swig_obj[0] = args;
23941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23942 if (!SWIG_IsOK(res1)) {
23943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23944 }
23945 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 resultobj = SWIG_From_int(static_cast< int >(result));
23953 return resultobj;
23954 fail:
23955 return NULL;
23956 }
23957
23958
23959 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23960 PyObject *resultobj = 0;
23961 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23962 bool result;
23963 void *argp1 = 0 ;
23964 int res1 = 0 ;
23965 PyObject *swig_obj[1] ;
23966
23967 if (!args) SWIG_fail;
23968 swig_obj[0] = args;
23969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23970 if (!SWIG_IsOK(res1)) {
23971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23972 }
23973 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23977 wxPyEndAllowThreads(__tstate);
23978 if (PyErr_Occurred()) SWIG_fail;
23979 }
23980 {
23981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23982 }
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *resultobj = 0;
23991 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23992 wxMenu *result = 0 ;
23993 void *argp1 = 0 ;
23994 int res1 = 0 ;
23995 PyObject *swig_obj[1] ;
23996
23997 if (!args) SWIG_fail;
23998 swig_obj[0] = args;
23999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24000 if (!SWIG_IsOK(res1)) {
24001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24002 }
24003 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24004 {
24005 PyThreadState* __tstate = wxPyBeginAllowThreads();
24006 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24007 wxPyEndAllowThreads(__tstate);
24008 if (PyErr_Occurred()) SWIG_fail;
24009 }
24010 {
24011 resultobj = wxPyMake_wxObject(result, (bool)0);
24012 }
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *obj;
24021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24022 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24023 return SWIG_Py_Void();
24024 }
24025
24026 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24027 return SWIG_Python_InitShadowInstance(args);
24028 }
24029
24030 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj = 0;
24032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24033 int arg2 = (int) 0 ;
24034 wxCloseEvent *result = 0 ;
24035 int val1 ;
24036 int ecode1 = 0 ;
24037 int val2 ;
24038 int ecode2 = 0 ;
24039 PyObject * obj0 = 0 ;
24040 PyObject * obj1 = 0 ;
24041 char * kwnames[] = {
24042 (char *) "type",(char *) "winid", NULL
24043 };
24044
24045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24046 if (obj0) {
24047 ecode1 = SWIG_AsVal_int(obj0, &val1);
24048 if (!SWIG_IsOK(ecode1)) {
24049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24050 }
24051 arg1 = static_cast< wxEventType >(val1);
24052 }
24053 if (obj1) {
24054 ecode2 = SWIG_AsVal_int(obj1, &val2);
24055 if (!SWIG_IsOK(ecode2)) {
24056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24057 }
24058 arg2 = static_cast< int >(val2);
24059 }
24060 {
24061 PyThreadState* __tstate = wxPyBeginAllowThreads();
24062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24063 wxPyEndAllowThreads(__tstate);
24064 if (PyErr_Occurred()) SWIG_fail;
24065 }
24066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24067 return resultobj;
24068 fail:
24069 return NULL;
24070 }
24071
24072
24073 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24074 PyObject *resultobj = 0;
24075 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24076 bool arg2 ;
24077 void *argp1 = 0 ;
24078 int res1 = 0 ;
24079 bool val2 ;
24080 int ecode2 = 0 ;
24081 PyObject * obj0 = 0 ;
24082 PyObject * obj1 = 0 ;
24083 char * kwnames[] = {
24084 (char *) "self",(char *) "logOff", NULL
24085 };
24086
24087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24089 if (!SWIG_IsOK(res1)) {
24090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24091 }
24092 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24093 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24094 if (!SWIG_IsOK(ecode2)) {
24095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24096 }
24097 arg2 = static_cast< bool >(val2);
24098 {
24099 PyThreadState* __tstate = wxPyBeginAllowThreads();
24100 (arg1)->SetLoggingOff(arg2);
24101 wxPyEndAllowThreads(__tstate);
24102 if (PyErr_Occurred()) SWIG_fail;
24103 }
24104 resultobj = SWIG_Py_Void();
24105 return resultobj;
24106 fail:
24107 return NULL;
24108 }
24109
24110
24111 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24112 PyObject *resultobj = 0;
24113 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24114 bool result;
24115 void *argp1 = 0 ;
24116 int res1 = 0 ;
24117 PyObject *swig_obj[1] ;
24118
24119 if (!args) SWIG_fail;
24120 swig_obj[0] = args;
24121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24122 if (!SWIG_IsOK(res1)) {
24123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24124 }
24125 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24126 {
24127 PyThreadState* __tstate = wxPyBeginAllowThreads();
24128 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24129 wxPyEndAllowThreads(__tstate);
24130 if (PyErr_Occurred()) SWIG_fail;
24131 }
24132 {
24133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24134 }
24135 return resultobj;
24136 fail:
24137 return NULL;
24138 }
24139
24140
24141 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24142 PyObject *resultobj = 0;
24143 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24144 bool arg2 = (bool) true ;
24145 void *argp1 = 0 ;
24146 int res1 = 0 ;
24147 bool val2 ;
24148 int ecode2 = 0 ;
24149 PyObject * obj0 = 0 ;
24150 PyObject * obj1 = 0 ;
24151 char * kwnames[] = {
24152 (char *) "self",(char *) "veto", NULL
24153 };
24154
24155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24157 if (!SWIG_IsOK(res1)) {
24158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24159 }
24160 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24161 if (obj1) {
24162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24163 if (!SWIG_IsOK(ecode2)) {
24164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24165 }
24166 arg2 = static_cast< bool >(val2);
24167 }
24168 {
24169 PyThreadState* __tstate = wxPyBeginAllowThreads();
24170 (arg1)->Veto(arg2);
24171 wxPyEndAllowThreads(__tstate);
24172 if (PyErr_Occurred()) SWIG_fail;
24173 }
24174 resultobj = SWIG_Py_Void();
24175 return resultobj;
24176 fail:
24177 return NULL;
24178 }
24179
24180
24181 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24182 PyObject *resultobj = 0;
24183 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24184 bool result;
24185 void *argp1 = 0 ;
24186 int res1 = 0 ;
24187 PyObject *swig_obj[1] ;
24188
24189 if (!args) SWIG_fail;
24190 swig_obj[0] = args;
24191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24192 if (!SWIG_IsOK(res1)) {
24193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24194 }
24195 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24196 {
24197 PyThreadState* __tstate = wxPyBeginAllowThreads();
24198 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24199 wxPyEndAllowThreads(__tstate);
24200 if (PyErr_Occurred()) SWIG_fail;
24201 }
24202 {
24203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24204 }
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj = 0;
24213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24214 bool arg2 ;
24215 void *argp1 = 0 ;
24216 int res1 = 0 ;
24217 bool val2 ;
24218 int ecode2 = 0 ;
24219 PyObject * obj0 = 0 ;
24220 PyObject * obj1 = 0 ;
24221 char * kwnames[] = {
24222 (char *) "self",(char *) "canVeto", NULL
24223 };
24224
24225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24232 if (!SWIG_IsOK(ecode2)) {
24233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24234 }
24235 arg2 = static_cast< bool >(val2);
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 (arg1)->SetCanVeto(arg2);
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 resultobj = SWIG_Py_Void();
24243 return resultobj;
24244 fail:
24245 return NULL;
24246 }
24247
24248
24249 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 PyObject *resultobj = 0;
24251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24252 bool result;
24253 void *argp1 = 0 ;
24254 int res1 = 0 ;
24255 PyObject *swig_obj[1] ;
24256
24257 if (!args) SWIG_fail;
24258 swig_obj[0] = args;
24259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24260 if (!SWIG_IsOK(res1)) {
24261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24262 }
24263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24264 {
24265 PyThreadState* __tstate = wxPyBeginAllowThreads();
24266 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 {
24271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24272 }
24273 return resultobj;
24274 fail:
24275 return NULL;
24276 }
24277
24278
24279 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24280 PyObject *obj;
24281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24282 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24283 return SWIG_Py_Void();
24284 }
24285
24286 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24287 return SWIG_Python_InitShadowInstance(args);
24288 }
24289
24290 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24291 PyObject *resultobj = 0;
24292 int arg1 = (int) 0 ;
24293 bool arg2 = (bool) false ;
24294 wxShowEvent *result = 0 ;
24295 int val1 ;
24296 int ecode1 = 0 ;
24297 bool val2 ;
24298 int ecode2 = 0 ;
24299 PyObject * obj0 = 0 ;
24300 PyObject * obj1 = 0 ;
24301 char * kwnames[] = {
24302 (char *) "winid",(char *) "show", NULL
24303 };
24304
24305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24306 if (obj0) {
24307 ecode1 = SWIG_AsVal_int(obj0, &val1);
24308 if (!SWIG_IsOK(ecode1)) {
24309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24310 }
24311 arg1 = static_cast< int >(val1);
24312 }
24313 if (obj1) {
24314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24315 if (!SWIG_IsOK(ecode2)) {
24316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24317 }
24318 arg2 = static_cast< bool >(val2);
24319 }
24320 {
24321 PyThreadState* __tstate = wxPyBeginAllowThreads();
24322 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24323 wxPyEndAllowThreads(__tstate);
24324 if (PyErr_Occurred()) SWIG_fail;
24325 }
24326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24327 return resultobj;
24328 fail:
24329 return NULL;
24330 }
24331
24332
24333 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24334 PyObject *resultobj = 0;
24335 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24336 bool arg2 ;
24337 void *argp1 = 0 ;
24338 int res1 = 0 ;
24339 bool val2 ;
24340 int ecode2 = 0 ;
24341 PyObject * obj0 = 0 ;
24342 PyObject * obj1 = 0 ;
24343 char * kwnames[] = {
24344 (char *) "self",(char *) "show", NULL
24345 };
24346
24347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24351 }
24352 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24354 if (!SWIG_IsOK(ecode2)) {
24355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24356 }
24357 arg2 = static_cast< bool >(val2);
24358 {
24359 PyThreadState* __tstate = wxPyBeginAllowThreads();
24360 (arg1)->SetShow(arg2);
24361 wxPyEndAllowThreads(__tstate);
24362 if (PyErr_Occurred()) SWIG_fail;
24363 }
24364 resultobj = SWIG_Py_Void();
24365 return resultobj;
24366 fail:
24367 return NULL;
24368 }
24369
24370
24371 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24372 PyObject *resultobj = 0;
24373 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24374 bool result;
24375 void *argp1 = 0 ;
24376 int res1 = 0 ;
24377 PyObject *swig_obj[1] ;
24378
24379 if (!args) SWIG_fail;
24380 swig_obj[0] = args;
24381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24382 if (!SWIG_IsOK(res1)) {
24383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24384 }
24385 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24389 wxPyEndAllowThreads(__tstate);
24390 if (PyErr_Occurred()) SWIG_fail;
24391 }
24392 {
24393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24394 }
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24402 PyObject *obj;
24403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24404 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24405 return SWIG_Py_Void();
24406 }
24407
24408 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 return SWIG_Python_InitShadowInstance(args);
24410 }
24411
24412 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24413 PyObject *resultobj = 0;
24414 int arg1 = (int) 0 ;
24415 bool arg2 = (bool) true ;
24416 wxIconizeEvent *result = 0 ;
24417 int val1 ;
24418 int ecode1 = 0 ;
24419 bool val2 ;
24420 int ecode2 = 0 ;
24421 PyObject * obj0 = 0 ;
24422 PyObject * obj1 = 0 ;
24423 char * kwnames[] = {
24424 (char *) "id",(char *) "iconized", NULL
24425 };
24426
24427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24428 if (obj0) {
24429 ecode1 = SWIG_AsVal_int(obj0, &val1);
24430 if (!SWIG_IsOK(ecode1)) {
24431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24432 }
24433 arg1 = static_cast< int >(val1);
24434 }
24435 if (obj1) {
24436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24437 if (!SWIG_IsOK(ecode2)) {
24438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24439 }
24440 arg2 = static_cast< bool >(val2);
24441 }
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24445 wxPyEndAllowThreads(__tstate);
24446 if (PyErr_Occurred()) SWIG_fail;
24447 }
24448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24449 return resultobj;
24450 fail:
24451 return NULL;
24452 }
24453
24454
24455 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24456 PyObject *resultobj = 0;
24457 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24458 bool result;
24459 void *argp1 = 0 ;
24460 int res1 = 0 ;
24461 PyObject *swig_obj[1] ;
24462
24463 if (!args) SWIG_fail;
24464 swig_obj[0] = args;
24465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24466 if (!SWIG_IsOK(res1)) {
24467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24468 }
24469 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 result = (bool)(arg1)->Iconized();
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 {
24477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24478 }
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24486 PyObject *obj;
24487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24488 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24489 return SWIG_Py_Void();
24490 }
24491
24492 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24493 return SWIG_Python_InitShadowInstance(args);
24494 }
24495
24496 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24497 PyObject *resultobj = 0;
24498 int arg1 = (int) 0 ;
24499 wxMaximizeEvent *result = 0 ;
24500 int val1 ;
24501 int ecode1 = 0 ;
24502 PyObject * obj0 = 0 ;
24503 char * kwnames[] = {
24504 (char *) "id", NULL
24505 };
24506
24507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24508 if (obj0) {
24509 ecode1 = SWIG_AsVal_int(obj0, &val1);
24510 if (!SWIG_IsOK(ecode1)) {
24511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24512 }
24513 arg1 = static_cast< int >(val1);
24514 }
24515 {
24516 PyThreadState* __tstate = wxPyBeginAllowThreads();
24517 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *obj;
24530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24531 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24532 return SWIG_Py_Void();
24533 }
24534
24535 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 return SWIG_Python_InitShadowInstance(args);
24537 }
24538
24539 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24540 PyObject *resultobj = 0;
24541 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24542 wxPoint result;
24543 void *argp1 = 0 ;
24544 int res1 = 0 ;
24545 PyObject *swig_obj[1] ;
24546
24547 if (!args) SWIG_fail;
24548 swig_obj[0] = args;
24549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24550 if (!SWIG_IsOK(res1)) {
24551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24552 }
24553 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24554 {
24555 PyThreadState* __tstate = wxPyBeginAllowThreads();
24556 result = (arg1)->GetPosition();
24557 wxPyEndAllowThreads(__tstate);
24558 if (PyErr_Occurred()) SWIG_fail;
24559 }
24560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24561 return resultobj;
24562 fail:
24563 return NULL;
24564 }
24565
24566
24567 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24568 PyObject *resultobj = 0;
24569 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24570 int result;
24571 void *argp1 = 0 ;
24572 int res1 = 0 ;
24573 PyObject *swig_obj[1] ;
24574
24575 if (!args) SWIG_fail;
24576 swig_obj[0] = args;
24577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24578 if (!SWIG_IsOK(res1)) {
24579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24580 }
24581 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24582 {
24583 PyThreadState* __tstate = wxPyBeginAllowThreads();
24584 result = (int)(arg1)->GetNumberOfFiles();
24585 wxPyEndAllowThreads(__tstate);
24586 if (PyErr_Occurred()) SWIG_fail;
24587 }
24588 resultobj = SWIG_From_int(static_cast< int >(result));
24589 return resultobj;
24590 fail:
24591 return NULL;
24592 }
24593
24594
24595 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 PyObject *resultobj = 0;
24597 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24598 PyObject *result = 0 ;
24599 void *argp1 = 0 ;
24600 int res1 = 0 ;
24601 PyObject *swig_obj[1] ;
24602
24603 if (!args) SWIG_fail;
24604 swig_obj[0] = args;
24605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24606 if (!SWIG_IsOK(res1)) {
24607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24608 }
24609 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24610 {
24611 PyThreadState* __tstate = wxPyBeginAllowThreads();
24612 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24613 wxPyEndAllowThreads(__tstate);
24614 if (PyErr_Occurred()) SWIG_fail;
24615 }
24616 resultobj = result;
24617 return resultobj;
24618 fail:
24619 return NULL;
24620 }
24621
24622
24623 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24624 PyObject *obj;
24625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24626 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24627 return SWIG_Py_Void();
24628 }
24629
24630 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24631 PyObject *resultobj = 0;
24632 int arg1 = (int) 0 ;
24633 wxUpdateUIEvent *result = 0 ;
24634 int val1 ;
24635 int ecode1 = 0 ;
24636 PyObject * obj0 = 0 ;
24637 char * kwnames[] = {
24638 (char *) "commandId", NULL
24639 };
24640
24641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24642 if (obj0) {
24643 ecode1 = SWIG_AsVal_int(obj0, &val1);
24644 if (!SWIG_IsOK(ecode1)) {
24645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24646 }
24647 arg1 = static_cast< int >(val1);
24648 }
24649 {
24650 PyThreadState* __tstate = wxPyBeginAllowThreads();
24651 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24652 wxPyEndAllowThreads(__tstate);
24653 if (PyErr_Occurred()) SWIG_fail;
24654 }
24655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24663 PyObject *resultobj = 0;
24664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24665 bool result;
24666 void *argp1 = 0 ;
24667 int res1 = 0 ;
24668 PyObject *swig_obj[1] ;
24669
24670 if (!args) SWIG_fail;
24671 swig_obj[0] = args;
24672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24673 if (!SWIG_IsOK(res1)) {
24674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24675 }
24676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24677 {
24678 PyThreadState* __tstate = wxPyBeginAllowThreads();
24679 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24685 }
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 PyObject *resultobj = 0;
24694 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24695 bool result;
24696 void *argp1 = 0 ;
24697 int res1 = 0 ;
24698 PyObject *swig_obj[1] ;
24699
24700 if (!args) SWIG_fail;
24701 swig_obj[0] = args;
24702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24703 if (!SWIG_IsOK(res1)) {
24704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24705 }
24706 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 {
24714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24715 }
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24723 PyObject *resultobj = 0;
24724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24725 bool result;
24726 void *argp1 = 0 ;
24727 int res1 = 0 ;
24728 PyObject *swig_obj[1] ;
24729
24730 if (!args) SWIG_fail;
24731 swig_obj[0] = args;
24732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24733 if (!SWIG_IsOK(res1)) {
24734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24735 }
24736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 {
24744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24745 }
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *resultobj = 0;
24754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24755 wxString result;
24756 void *argp1 = 0 ;
24757 int res1 = 0 ;
24758 PyObject *swig_obj[1] ;
24759
24760 if (!args) SWIG_fail;
24761 swig_obj[0] = args;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24765 }
24766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 {
24774 #if wxUSE_UNICODE
24775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24776 #else
24777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24778 #endif
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24787 PyObject *resultobj = 0;
24788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24789 bool result;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 PyObject *swig_obj[1] ;
24793
24794 if (!args) SWIG_fail;
24795 swig_obj[0] = args;
24796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24799 }
24800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 {
24808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24809 }
24810 return resultobj;
24811 fail:
24812 return NULL;
24813 }
24814
24815
24816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24817 PyObject *resultobj = 0;
24818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24819 bool result;
24820 void *argp1 = 0 ;
24821 int res1 = 0 ;
24822 PyObject *swig_obj[1] ;
24823
24824 if (!args) SWIG_fail;
24825 swig_obj[0] = args;
24826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24827 if (!SWIG_IsOK(res1)) {
24828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24829 }
24830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24831 {
24832 PyThreadState* __tstate = wxPyBeginAllowThreads();
24833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24834 wxPyEndAllowThreads(__tstate);
24835 if (PyErr_Occurred()) SWIG_fail;
24836 }
24837 {
24838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24839 }
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24849 bool result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 {
24868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24869 }
24870 return resultobj;
24871 fail:
24872 return NULL;
24873 }
24874
24875
24876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24877 PyObject *resultobj = 0;
24878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24879 bool result;
24880 void *argp1 = 0 ;
24881 int res1 = 0 ;
24882 PyObject *swig_obj[1] ;
24883
24884 if (!args) SWIG_fail;
24885 swig_obj[0] = args;
24886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24887 if (!SWIG_IsOK(res1)) {
24888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24889 }
24890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24891 {
24892 PyThreadState* __tstate = wxPyBeginAllowThreads();
24893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24894 wxPyEndAllowThreads(__tstate);
24895 if (PyErr_Occurred()) SWIG_fail;
24896 }
24897 {
24898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24899 }
24900 return resultobj;
24901 fail:
24902 return NULL;
24903 }
24904
24905
24906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24907 PyObject *resultobj = 0;
24908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24909 bool arg2 ;
24910 void *argp1 = 0 ;
24911 int res1 = 0 ;
24912 bool val2 ;
24913 int ecode2 = 0 ;
24914 PyObject * obj0 = 0 ;
24915 PyObject * obj1 = 0 ;
24916 char * kwnames[] = {
24917 (char *) "self",(char *) "check", NULL
24918 };
24919
24920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24922 if (!SWIG_IsOK(res1)) {
24923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24924 }
24925 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24927 if (!SWIG_IsOK(ecode2)) {
24928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24929 }
24930 arg2 = static_cast< bool >(val2);
24931 {
24932 PyThreadState* __tstate = wxPyBeginAllowThreads();
24933 (arg1)->Check(arg2);
24934 wxPyEndAllowThreads(__tstate);
24935 if (PyErr_Occurred()) SWIG_fail;
24936 }
24937 resultobj = SWIG_Py_Void();
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj = 0;
24946 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24947 bool arg2 ;
24948 void *argp1 = 0 ;
24949 int res1 = 0 ;
24950 bool val2 ;
24951 int ecode2 = 0 ;
24952 PyObject * obj0 = 0 ;
24953 PyObject * obj1 = 0 ;
24954 char * kwnames[] = {
24955 (char *) "self",(char *) "enable", NULL
24956 };
24957
24958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24960 if (!SWIG_IsOK(res1)) {
24961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24962 }
24963 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24965 if (!SWIG_IsOK(ecode2)) {
24966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24967 }
24968 arg2 = static_cast< bool >(val2);
24969 {
24970 PyThreadState* __tstate = wxPyBeginAllowThreads();
24971 (arg1)->Enable(arg2);
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 resultobj = SWIG_Py_Void();
24976 return resultobj;
24977 fail:
24978 return NULL;
24979 }
24980
24981
24982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24983 PyObject *resultobj = 0;
24984 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24985 bool arg2 ;
24986 void *argp1 = 0 ;
24987 int res1 = 0 ;
24988 bool val2 ;
24989 int ecode2 = 0 ;
24990 PyObject * obj0 = 0 ;
24991 PyObject * obj1 = 0 ;
24992 char * kwnames[] = {
24993 (char *) "self",(char *) "show", NULL
24994 };
24995
24996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24998 if (!SWIG_IsOK(res1)) {
24999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25000 }
25001 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25003 if (!SWIG_IsOK(ecode2)) {
25004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25005 }
25006 arg2 = static_cast< bool >(val2);
25007 {
25008 PyThreadState* __tstate = wxPyBeginAllowThreads();
25009 (arg1)->Show(arg2);
25010 wxPyEndAllowThreads(__tstate);
25011 if (PyErr_Occurred()) SWIG_fail;
25012 }
25013 resultobj = SWIG_Py_Void();
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj = 0;
25022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25023 wxString *arg2 = 0 ;
25024 void *argp1 = 0 ;
25025 int res1 = 0 ;
25026 bool temp2 = false ;
25027 PyObject * obj0 = 0 ;
25028 PyObject * obj1 = 0 ;
25029 char * kwnames[] = {
25030 (char *) "self",(char *) "text", NULL
25031 };
25032
25033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25037 }
25038 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25039 {
25040 arg2 = wxString_in_helper(obj1);
25041 if (arg2 == NULL) SWIG_fail;
25042 temp2 = true;
25043 }
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 (arg1)->SetText((wxString const &)*arg2);
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 resultobj = SWIG_Py_Void();
25051 {
25052 if (temp2)
25053 delete arg2;
25054 }
25055 return resultobj;
25056 fail:
25057 {
25058 if (temp2)
25059 delete arg2;
25060 }
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj = 0;
25067 long arg1 ;
25068 long val1 ;
25069 int ecode1 = 0 ;
25070 PyObject * obj0 = 0 ;
25071 char * kwnames[] = {
25072 (char *) "updateInterval", NULL
25073 };
25074
25075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25076 ecode1 = SWIG_AsVal_long(obj0, &val1);
25077 if (!SWIG_IsOK(ecode1)) {
25078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25079 }
25080 arg1 = static_cast< long >(val1);
25081 {
25082 PyThreadState* __tstate = wxPyBeginAllowThreads();
25083 wxUpdateUIEvent::SetUpdateInterval(arg1);
25084 wxPyEndAllowThreads(__tstate);
25085 if (PyErr_Occurred()) SWIG_fail;
25086 }
25087 resultobj = SWIG_Py_Void();
25088 return resultobj;
25089 fail:
25090 return NULL;
25091 }
25092
25093
25094 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25095 PyObject *resultobj = 0;
25096 long result;
25097
25098 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25099 {
25100 PyThreadState* __tstate = wxPyBeginAllowThreads();
25101 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 resultobj = SWIG_From_long(static_cast< long >(result));
25106 return resultobj;
25107 fail:
25108 return NULL;
25109 }
25110
25111
25112 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25113 PyObject *resultobj = 0;
25114 wxWindow *arg1 = (wxWindow *) 0 ;
25115 bool result;
25116 void *argp1 = 0 ;
25117 int res1 = 0 ;
25118 PyObject * obj0 = 0 ;
25119 char * kwnames[] = {
25120 (char *) "win", NULL
25121 };
25122
25123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25125 if (!SWIG_IsOK(res1)) {
25126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25127 }
25128 arg1 = reinterpret_cast< wxWindow * >(argp1);
25129 {
25130 PyThreadState* __tstate = wxPyBeginAllowThreads();
25131 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 {
25136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25145 PyObject *resultobj = 0;
25146
25147 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25148 {
25149 PyThreadState* __tstate = wxPyBeginAllowThreads();
25150 wxUpdateUIEvent::ResetUpdateTime();
25151 wxPyEndAllowThreads(__tstate);
25152 if (PyErr_Occurred()) SWIG_fail;
25153 }
25154 resultobj = SWIG_Py_Void();
25155 return resultobj;
25156 fail:
25157 return NULL;
25158 }
25159
25160
25161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25162 PyObject *resultobj = 0;
25163 wxUpdateUIMode arg1 ;
25164 int val1 ;
25165 int ecode1 = 0 ;
25166 PyObject * obj0 = 0 ;
25167 char * kwnames[] = {
25168 (char *) "mode", NULL
25169 };
25170
25171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25172 ecode1 = SWIG_AsVal_int(obj0, &val1);
25173 if (!SWIG_IsOK(ecode1)) {
25174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25175 }
25176 arg1 = static_cast< wxUpdateUIMode >(val1);
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 wxUpdateUIEvent::SetMode(arg1);
25180 wxPyEndAllowThreads(__tstate);
25181 if (PyErr_Occurred()) SWIG_fail;
25182 }
25183 resultobj = SWIG_Py_Void();
25184 return resultobj;
25185 fail:
25186 return NULL;
25187 }
25188
25189
25190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25191 PyObject *resultobj = 0;
25192 wxUpdateUIMode result;
25193
25194 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25195 {
25196 PyThreadState* __tstate = wxPyBeginAllowThreads();
25197 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25198 wxPyEndAllowThreads(__tstate);
25199 if (PyErr_Occurred()) SWIG_fail;
25200 }
25201 resultobj = SWIG_From_int(static_cast< int >(result));
25202 return resultobj;
25203 fail:
25204 return NULL;
25205 }
25206
25207
25208 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25209 PyObject *obj;
25210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25211 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25212 return SWIG_Py_Void();
25213 }
25214
25215 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25216 return SWIG_Python_InitShadowInstance(args);
25217 }
25218
25219 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25220 PyObject *resultobj = 0;
25221 wxSysColourChangedEvent *result = 0 ;
25222
25223 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25227 wxPyEndAllowThreads(__tstate);
25228 if (PyErr_Occurred()) SWIG_fail;
25229 }
25230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25231 return resultobj;
25232 fail:
25233 return NULL;
25234 }
25235
25236
25237 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25238 PyObject *obj;
25239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25240 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25241 return SWIG_Py_Void();
25242 }
25243
25244 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25245 return SWIG_Python_InitShadowInstance(args);
25246 }
25247
25248 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25249 PyObject *resultobj = 0;
25250 int arg1 = (int) 0 ;
25251 wxWindow *arg2 = (wxWindow *) NULL ;
25252 wxMouseCaptureChangedEvent *result = 0 ;
25253 int val1 ;
25254 int ecode1 = 0 ;
25255 void *argp2 = 0 ;
25256 int res2 = 0 ;
25257 PyObject * obj0 = 0 ;
25258 PyObject * obj1 = 0 ;
25259 char * kwnames[] = {
25260 (char *) "winid",(char *) "gainedCapture", NULL
25261 };
25262
25263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25264 if (obj0) {
25265 ecode1 = SWIG_AsVal_int(obj0, &val1);
25266 if (!SWIG_IsOK(ecode1)) {
25267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25268 }
25269 arg1 = static_cast< int >(val1);
25270 }
25271 if (obj1) {
25272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25273 if (!SWIG_IsOK(res2)) {
25274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25275 }
25276 arg2 = reinterpret_cast< wxWindow * >(argp2);
25277 }
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25285 return resultobj;
25286 fail:
25287 return NULL;
25288 }
25289
25290
25291 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25292 PyObject *resultobj = 0;
25293 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25294 wxWindow *result = 0 ;
25295 void *argp1 = 0 ;
25296 int res1 = 0 ;
25297 PyObject *swig_obj[1] ;
25298
25299 if (!args) SWIG_fail;
25300 swig_obj[0] = args;
25301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25304 }
25305 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25306 {
25307 PyThreadState* __tstate = wxPyBeginAllowThreads();
25308 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25309 wxPyEndAllowThreads(__tstate);
25310 if (PyErr_Occurred()) SWIG_fail;
25311 }
25312 {
25313 resultobj = wxPyMake_wxObject(result, (bool)0);
25314 }
25315 return resultobj;
25316 fail:
25317 return NULL;
25318 }
25319
25320
25321 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25322 PyObject *obj;
25323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25324 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25325 return SWIG_Py_Void();
25326 }
25327
25328 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25329 return SWIG_Python_InitShadowInstance(args);
25330 }
25331
25332 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25333 PyObject *resultobj = 0;
25334 wxDisplayChangedEvent *result = 0 ;
25335
25336 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 PyObject *obj;
25352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25353 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25354 return SWIG_Py_Void();
25355 }
25356
25357 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25358 return SWIG_Python_InitShadowInstance(args);
25359 }
25360
25361 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25362 PyObject *resultobj = 0;
25363 int arg1 = (int) 0 ;
25364 wxPaletteChangedEvent *result = 0 ;
25365 int val1 ;
25366 int ecode1 = 0 ;
25367 PyObject * obj0 = 0 ;
25368 char * kwnames[] = {
25369 (char *) "id", NULL
25370 };
25371
25372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25373 if (obj0) {
25374 ecode1 = SWIG_AsVal_int(obj0, &val1);
25375 if (!SWIG_IsOK(ecode1)) {
25376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25377 }
25378 arg1 = static_cast< int >(val1);
25379 }
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25383 wxPyEndAllowThreads(__tstate);
25384 if (PyErr_Occurred()) SWIG_fail;
25385 }
25386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25394 PyObject *resultobj = 0;
25395 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25396 wxWindow *arg2 = (wxWindow *) 0 ;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 void *argp2 = 0 ;
25400 int res2 = 0 ;
25401 PyObject * obj0 = 0 ;
25402 PyObject * obj1 = 0 ;
25403 char * kwnames[] = {
25404 (char *) "self",(char *) "win", NULL
25405 };
25406
25407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25409 if (!SWIG_IsOK(res1)) {
25410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25411 }
25412 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25414 if (!SWIG_IsOK(res2)) {
25415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25416 }
25417 arg2 = reinterpret_cast< wxWindow * >(argp2);
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 (arg1)->SetChangedWindow(arg2);
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 resultobj = SWIG_Py_Void();
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25432 PyObject *resultobj = 0;
25433 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25434 wxWindow *result = 0 ;
25435 void *argp1 = 0 ;
25436 int res1 = 0 ;
25437 PyObject *swig_obj[1] ;
25438
25439 if (!args) SWIG_fail;
25440 swig_obj[0] = args;
25441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25442 if (!SWIG_IsOK(res1)) {
25443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25444 }
25445 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 result = (wxWindow *)(arg1)->GetChangedWindow();
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 {
25453 resultobj = wxPyMake_wxObject(result, (bool)0);
25454 }
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25462 PyObject *obj;
25463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25464 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25465 return SWIG_Py_Void();
25466 }
25467
25468 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25469 return SWIG_Python_InitShadowInstance(args);
25470 }
25471
25472 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25473 PyObject *resultobj = 0;
25474 int arg1 = (int) 0 ;
25475 wxQueryNewPaletteEvent *result = 0 ;
25476 int val1 ;
25477 int ecode1 = 0 ;
25478 PyObject * obj0 = 0 ;
25479 char * kwnames[] = {
25480 (char *) "winid", NULL
25481 };
25482
25483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25484 if (obj0) {
25485 ecode1 = SWIG_AsVal_int(obj0, &val1);
25486 if (!SWIG_IsOK(ecode1)) {
25487 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25488 }
25489 arg1 = static_cast< int >(val1);
25490 }
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25505 PyObject *resultobj = 0;
25506 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25507 bool arg2 ;
25508 void *argp1 = 0 ;
25509 int res1 = 0 ;
25510 bool val2 ;
25511 int ecode2 = 0 ;
25512 PyObject * obj0 = 0 ;
25513 PyObject * obj1 = 0 ;
25514 char * kwnames[] = {
25515 (char *) "self",(char *) "realized", NULL
25516 };
25517
25518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25520 if (!SWIG_IsOK(res1)) {
25521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25522 }
25523 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25525 if (!SWIG_IsOK(ecode2)) {
25526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25527 }
25528 arg2 = static_cast< bool >(val2);
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 (arg1)->SetPaletteRealized(arg2);
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 resultobj = SWIG_Py_Void();
25536 return resultobj;
25537 fail:
25538 return NULL;
25539 }
25540
25541
25542 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25543 PyObject *resultobj = 0;
25544 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25545 bool result;
25546 void *argp1 = 0 ;
25547 int res1 = 0 ;
25548 PyObject *swig_obj[1] ;
25549
25550 if (!args) SWIG_fail;
25551 swig_obj[0] = args;
25552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25553 if (!SWIG_IsOK(res1)) {
25554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25555 }
25556 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25557 {
25558 PyThreadState* __tstate = wxPyBeginAllowThreads();
25559 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25560 wxPyEndAllowThreads(__tstate);
25561 if (PyErr_Occurred()) SWIG_fail;
25562 }
25563 {
25564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25565 }
25566 return resultobj;
25567 fail:
25568 return NULL;
25569 }
25570
25571
25572 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25573 PyObject *obj;
25574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25575 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25576 return SWIG_Py_Void();
25577 }
25578
25579 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 return SWIG_Python_InitShadowInstance(args);
25581 }
25582
25583 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25584 PyObject *resultobj = 0;
25585 wxNavigationKeyEvent *result = 0 ;
25586
25587 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25588 {
25589 PyThreadState* __tstate = wxPyBeginAllowThreads();
25590 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25595 return resultobj;
25596 fail:
25597 return NULL;
25598 }
25599
25600
25601 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25602 PyObject *resultobj = 0;
25603 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25604 bool result;
25605 void *argp1 = 0 ;
25606 int res1 = 0 ;
25607 PyObject *swig_obj[1] ;
25608
25609 if (!args) SWIG_fail;
25610 swig_obj[0] = args;
25611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25612 if (!SWIG_IsOK(res1)) {
25613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25614 }
25615 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25616 {
25617 PyThreadState* __tstate = wxPyBeginAllowThreads();
25618 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25619 wxPyEndAllowThreads(__tstate);
25620 if (PyErr_Occurred()) SWIG_fail;
25621 }
25622 {
25623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25624 }
25625 return resultobj;
25626 fail:
25627 return NULL;
25628 }
25629
25630
25631 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25632 PyObject *resultobj = 0;
25633 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25634 bool arg2 ;
25635 void *argp1 = 0 ;
25636 int res1 = 0 ;
25637 bool val2 ;
25638 int ecode2 = 0 ;
25639 PyObject * obj0 = 0 ;
25640 PyObject * obj1 = 0 ;
25641 char * kwnames[] = {
25642 (char *) "self",(char *) "forward", NULL
25643 };
25644
25645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25647 if (!SWIG_IsOK(res1)) {
25648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25649 }
25650 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25651 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25652 if (!SWIG_IsOK(ecode2)) {
25653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25654 }
25655 arg2 = static_cast< bool >(val2);
25656 {
25657 PyThreadState* __tstate = wxPyBeginAllowThreads();
25658 (arg1)->SetDirection(arg2);
25659 wxPyEndAllowThreads(__tstate);
25660 if (PyErr_Occurred()) SWIG_fail;
25661 }
25662 resultobj = SWIG_Py_Void();
25663 return resultobj;
25664 fail:
25665 return NULL;
25666 }
25667
25668
25669 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25670 PyObject *resultobj = 0;
25671 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25672 bool result;
25673 void *argp1 = 0 ;
25674 int res1 = 0 ;
25675 PyObject *swig_obj[1] ;
25676
25677 if (!args) SWIG_fail;
25678 swig_obj[0] = args;
25679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25680 if (!SWIG_IsOK(res1)) {
25681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25682 }
25683 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25684 {
25685 PyThreadState* __tstate = wxPyBeginAllowThreads();
25686 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25687 wxPyEndAllowThreads(__tstate);
25688 if (PyErr_Occurred()) SWIG_fail;
25689 }
25690 {
25691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25692 }
25693 return resultobj;
25694 fail:
25695 return NULL;
25696 }
25697
25698
25699 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25700 PyObject *resultobj = 0;
25701 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25702 bool arg2 ;
25703 void *argp1 = 0 ;
25704 int res1 = 0 ;
25705 bool val2 ;
25706 int ecode2 = 0 ;
25707 PyObject * obj0 = 0 ;
25708 PyObject * obj1 = 0 ;
25709 char * kwnames[] = {
25710 (char *) "self",(char *) "ischange", NULL
25711 };
25712
25713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25717 }
25718 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25719 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25720 if (!SWIG_IsOK(ecode2)) {
25721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25722 }
25723 arg2 = static_cast< bool >(val2);
25724 {
25725 PyThreadState* __tstate = wxPyBeginAllowThreads();
25726 (arg1)->SetWindowChange(arg2);
25727 wxPyEndAllowThreads(__tstate);
25728 if (PyErr_Occurred()) SWIG_fail;
25729 }
25730 resultobj = SWIG_Py_Void();
25731 return resultobj;
25732 fail:
25733 return NULL;
25734 }
25735
25736
25737 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25738 PyObject *resultobj = 0;
25739 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 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_wxNavigationKeyEvent, 0 | 0 );
25748 if (!SWIG_IsOK(res1)) {
25749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25750 }
25751 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25752 {
25753 PyThreadState* __tstate = wxPyBeginAllowThreads();
25754 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
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_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25768 PyObject *resultobj = 0;
25769 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25770 bool arg2 ;
25771 void *argp1 = 0 ;
25772 int res1 = 0 ;
25773 bool val2 ;
25774 int ecode2 = 0 ;
25775 PyObject * obj0 = 0 ;
25776 PyObject * obj1 = 0 ;
25777 char * kwnames[] = {
25778 (char *) "self",(char *) "bIs", NULL
25779 };
25780
25781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25783 if (!SWIG_IsOK(res1)) {
25784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25785 }
25786 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25787 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25788 if (!SWIG_IsOK(ecode2)) {
25789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25790 }
25791 arg2 = static_cast< bool >(val2);
25792 {
25793 PyThreadState* __tstate = wxPyBeginAllowThreads();
25794 (arg1)->SetFromTab(arg2);
25795 wxPyEndAllowThreads(__tstate);
25796 if (PyErr_Occurred()) SWIG_fail;
25797 }
25798 resultobj = SWIG_Py_Void();
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = 0;
25807 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25808 long arg2 ;
25809 void *argp1 = 0 ;
25810 int res1 = 0 ;
25811 long val2 ;
25812 int ecode2 = 0 ;
25813 PyObject * obj0 = 0 ;
25814 PyObject * obj1 = 0 ;
25815 char * kwnames[] = {
25816 (char *) "self",(char *) "flags", NULL
25817 };
25818
25819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25821 if (!SWIG_IsOK(res1)) {
25822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25823 }
25824 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25825 ecode2 = SWIG_AsVal_long(obj1, &val2);
25826 if (!SWIG_IsOK(ecode2)) {
25827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25828 }
25829 arg2 = static_cast< long >(val2);
25830 {
25831 PyThreadState* __tstate = wxPyBeginAllowThreads();
25832 (arg1)->SetFlags(arg2);
25833 wxPyEndAllowThreads(__tstate);
25834 if (PyErr_Occurred()) SWIG_fail;
25835 }
25836 resultobj = SWIG_Py_Void();
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25844 PyObject *resultobj = 0;
25845 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25846 wxWindow *result = 0 ;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 PyObject *swig_obj[1] ;
25850
25851 if (!args) SWIG_fail;
25852 swig_obj[0] = args;
25853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25856 }
25857 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25858 {
25859 PyThreadState* __tstate = wxPyBeginAllowThreads();
25860 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25861 wxPyEndAllowThreads(__tstate);
25862 if (PyErr_Occurred()) SWIG_fail;
25863 }
25864 {
25865 resultobj = wxPyMake_wxObject(result, (bool)0);
25866 }
25867 return resultobj;
25868 fail:
25869 return NULL;
25870 }
25871
25872
25873 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25874 PyObject *resultobj = 0;
25875 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25876 wxWindow *arg2 = (wxWindow *) 0 ;
25877 void *argp1 = 0 ;
25878 int res1 = 0 ;
25879 void *argp2 = 0 ;
25880 int res2 = 0 ;
25881 PyObject * obj0 = 0 ;
25882 PyObject * obj1 = 0 ;
25883 char * kwnames[] = {
25884 (char *) "self",(char *) "win", NULL
25885 };
25886
25887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25889 if (!SWIG_IsOK(res1)) {
25890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25891 }
25892 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25893 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25894 if (!SWIG_IsOK(res2)) {
25895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25896 }
25897 arg2 = reinterpret_cast< wxWindow * >(argp2);
25898 {
25899 PyThreadState* __tstate = wxPyBeginAllowThreads();
25900 (arg1)->SetCurrentFocus(arg2);
25901 wxPyEndAllowThreads(__tstate);
25902 if (PyErr_Occurred()) SWIG_fail;
25903 }
25904 resultobj = SWIG_Py_Void();
25905 return resultobj;
25906 fail:
25907 return NULL;
25908 }
25909
25910
25911 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25912 PyObject *obj;
25913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25914 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25915 return SWIG_Py_Void();
25916 }
25917
25918 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 return SWIG_Python_InitShadowInstance(args);
25920 }
25921
25922 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25923 PyObject *resultobj = 0;
25924 wxWindow *arg1 = (wxWindow *) NULL ;
25925 wxWindowCreateEvent *result = 0 ;
25926 void *argp1 = 0 ;
25927 int res1 = 0 ;
25928 PyObject * obj0 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "win", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25934 if (obj0) {
25935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25936 if (!SWIG_IsOK(res1)) {
25937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25938 }
25939 arg1 = reinterpret_cast< wxWindow * >(argp1);
25940 }
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25944 wxPyEndAllowThreads(__tstate);
25945 if (PyErr_Occurred()) SWIG_fail;
25946 }
25947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25955 PyObject *resultobj = 0;
25956 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25957 wxWindow *result = 0 ;
25958 void *argp1 = 0 ;
25959 int res1 = 0 ;
25960 PyObject *swig_obj[1] ;
25961
25962 if (!args) SWIG_fail;
25963 swig_obj[0] = args;
25964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25965 if (!SWIG_IsOK(res1)) {
25966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25967 }
25968 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 {
25976 resultobj = wxPyMake_wxObject(result, (bool)0);
25977 }
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25985 PyObject *obj;
25986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25987 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25988 return SWIG_Py_Void();
25989 }
25990
25991 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25992 return SWIG_Python_InitShadowInstance(args);
25993 }
25994
25995 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25996 PyObject *resultobj = 0;
25997 wxWindow *arg1 = (wxWindow *) NULL ;
25998 wxWindowDestroyEvent *result = 0 ;
25999 void *argp1 = 0 ;
26000 int res1 = 0 ;
26001 PyObject * obj0 = 0 ;
26002 char * kwnames[] = {
26003 (char *) "win", NULL
26004 };
26005
26006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26007 if (obj0) {
26008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26009 if (!SWIG_IsOK(res1)) {
26010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26011 }
26012 arg1 = reinterpret_cast< wxWindow * >(argp1);
26013 }
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26028 PyObject *resultobj = 0;
26029 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26030 wxWindow *result = 0 ;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject *swig_obj[1] ;
26034
26035 if (!args) SWIG_fail;
26036 swig_obj[0] = args;
26037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26038 if (!SWIG_IsOK(res1)) {
26039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26040 }
26041 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 {
26049 resultobj = wxPyMake_wxObject(result, (bool)0);
26050 }
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26058 PyObject *obj;
26059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26060 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26061 return SWIG_Py_Void();
26062 }
26063
26064 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26065 return SWIG_Python_InitShadowInstance(args);
26066 }
26067
26068 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = 0;
26070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26071 int arg2 = (int) 0 ;
26072 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26073 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26074 wxContextMenuEvent *result = 0 ;
26075 int val1 ;
26076 int ecode1 = 0 ;
26077 int val2 ;
26078 int ecode2 = 0 ;
26079 wxPoint temp3 ;
26080 PyObject * obj0 = 0 ;
26081 PyObject * obj1 = 0 ;
26082 PyObject * obj2 = 0 ;
26083 char * kwnames[] = {
26084 (char *) "type",(char *) "winid",(char *) "pt", NULL
26085 };
26086
26087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26088 if (obj0) {
26089 ecode1 = SWIG_AsVal_int(obj0, &val1);
26090 if (!SWIG_IsOK(ecode1)) {
26091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26092 }
26093 arg1 = static_cast< wxEventType >(val1);
26094 }
26095 if (obj1) {
26096 ecode2 = SWIG_AsVal_int(obj1, &val2);
26097 if (!SWIG_IsOK(ecode2)) {
26098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26099 }
26100 arg2 = static_cast< int >(val2);
26101 }
26102 if (obj2) {
26103 {
26104 arg3 = &temp3;
26105 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26106 }
26107 }
26108 {
26109 PyThreadState* __tstate = wxPyBeginAllowThreads();
26110 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26111 wxPyEndAllowThreads(__tstate);
26112 if (PyErr_Occurred()) SWIG_fail;
26113 }
26114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26122 PyObject *resultobj = 0;
26123 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26124 wxPoint *result = 0 ;
26125 void *argp1 = 0 ;
26126 int res1 = 0 ;
26127 PyObject *swig_obj[1] ;
26128
26129 if (!args) SWIG_fail;
26130 swig_obj[0] = args;
26131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26134 }
26135 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 {
26139 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26140 result = (wxPoint *) &_result_ref;
26141 }
26142 wxPyEndAllowThreads(__tstate);
26143 if (PyErr_Occurred()) SWIG_fail;
26144 }
26145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26153 PyObject *resultobj = 0;
26154 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26155 wxPoint *arg2 = 0 ;
26156 void *argp1 = 0 ;
26157 int res1 = 0 ;
26158 wxPoint temp2 ;
26159 PyObject * obj0 = 0 ;
26160 PyObject * obj1 = 0 ;
26161 char * kwnames[] = {
26162 (char *) "self",(char *) "pos", NULL
26163 };
26164
26165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26167 if (!SWIG_IsOK(res1)) {
26168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26169 }
26170 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26171 {
26172 arg2 = &temp2;
26173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 (arg1)->SetPosition((wxPoint const &)*arg2);
26178 wxPyEndAllowThreads(__tstate);
26179 if (PyErr_Occurred()) SWIG_fail;
26180 }
26181 resultobj = SWIG_Py_Void();
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26189 PyObject *obj;
26190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26191 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26192 return SWIG_Py_Void();
26193 }
26194
26195 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26196 return SWIG_Python_InitShadowInstance(args);
26197 }
26198
26199 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26200 PyObject *resultobj = 0;
26201 wxIdleEvent *result = 0 ;
26202
26203 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26204 {
26205 PyThreadState* __tstate = wxPyBeginAllowThreads();
26206 result = (wxIdleEvent *)new wxIdleEvent();
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26211 return resultobj;
26212 fail:
26213 return NULL;
26214 }
26215
26216
26217 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26218 PyObject *resultobj = 0;
26219 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26220 bool arg2 = (bool) true ;
26221 void *argp1 = 0 ;
26222 int res1 = 0 ;
26223 bool val2 ;
26224 int ecode2 = 0 ;
26225 PyObject * obj0 = 0 ;
26226 PyObject * obj1 = 0 ;
26227 char * kwnames[] = {
26228 (char *) "self",(char *) "needMore", NULL
26229 };
26230
26231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26233 if (!SWIG_IsOK(res1)) {
26234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26235 }
26236 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26237 if (obj1) {
26238 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26239 if (!SWIG_IsOK(ecode2)) {
26240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26241 }
26242 arg2 = static_cast< bool >(val2);
26243 }
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 (arg1)->RequestMore(arg2);
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_Py_Void();
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26258 PyObject *resultobj = 0;
26259 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26260 bool result;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 PyObject *swig_obj[1] ;
26264
26265 if (!args) SWIG_fail;
26266 swig_obj[0] = args;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26270 }
26271 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 {
26279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26280 }
26281 return resultobj;
26282 fail:
26283 return NULL;
26284 }
26285
26286
26287 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj = 0;
26289 wxIdleMode arg1 ;
26290 int val1 ;
26291 int ecode1 = 0 ;
26292 PyObject * obj0 = 0 ;
26293 char * kwnames[] = {
26294 (char *) "mode", NULL
26295 };
26296
26297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26298 ecode1 = SWIG_AsVal_int(obj0, &val1);
26299 if (!SWIG_IsOK(ecode1)) {
26300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26301 }
26302 arg1 = static_cast< wxIdleMode >(val1);
26303 {
26304 PyThreadState* __tstate = wxPyBeginAllowThreads();
26305 wxIdleEvent::SetMode(arg1);
26306 wxPyEndAllowThreads(__tstate);
26307 if (PyErr_Occurred()) SWIG_fail;
26308 }
26309 resultobj = SWIG_Py_Void();
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26317 PyObject *resultobj = 0;
26318 wxIdleMode result;
26319
26320 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 result = (wxIdleMode)wxIdleEvent::GetMode();
26324 wxPyEndAllowThreads(__tstate);
26325 if (PyErr_Occurred()) SWIG_fail;
26326 }
26327 resultobj = SWIG_From_int(static_cast< int >(result));
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26335 PyObject *resultobj = 0;
26336 wxWindow *arg1 = (wxWindow *) 0 ;
26337 bool result;
26338 void *argp1 = 0 ;
26339 int res1 = 0 ;
26340 PyObject * obj0 = 0 ;
26341 char * kwnames[] = {
26342 (char *) "win", NULL
26343 };
26344
26345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26347 if (!SWIG_IsOK(res1)) {
26348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26349 }
26350 arg1 = reinterpret_cast< wxWindow * >(argp1);
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (bool)wxIdleEvent::CanSend(arg1);
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 {
26358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26359 }
26360 return resultobj;
26361 fail:
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26367 PyObject *obj;
26368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26369 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26370 return SWIG_Py_Void();
26371 }
26372
26373 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26374 return SWIG_Python_InitShadowInstance(args);
26375 }
26376
26377 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26378 PyObject *resultobj = 0;
26379 int arg1 = (int) 0 ;
26380 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26381 wxPyEvent *result = 0 ;
26382 int val1 ;
26383 int ecode1 = 0 ;
26384 int val2 ;
26385 int ecode2 = 0 ;
26386 PyObject * obj0 = 0 ;
26387 PyObject * obj1 = 0 ;
26388 char * kwnames[] = {
26389 (char *) "winid",(char *) "eventType", NULL
26390 };
26391
26392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26393 if (obj0) {
26394 ecode1 = SWIG_AsVal_int(obj0, &val1);
26395 if (!SWIG_IsOK(ecode1)) {
26396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26397 }
26398 arg1 = static_cast< int >(val1);
26399 }
26400 if (obj1) {
26401 ecode2 = SWIG_AsVal_int(obj1, &val2);
26402 if (!SWIG_IsOK(ecode2)) {
26403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26404 }
26405 arg2 = static_cast< wxEventType >(val2);
26406 }
26407 {
26408 PyThreadState* __tstate = wxPyBeginAllowThreads();
26409 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26410 wxPyEndAllowThreads(__tstate);
26411 if (PyErr_Occurred()) SWIG_fail;
26412 }
26413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26421 PyObject *resultobj = 0;
26422 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26423 void *argp1 = 0 ;
26424 int res1 = 0 ;
26425 PyObject *swig_obj[1] ;
26426
26427 if (!args) SWIG_fail;
26428 swig_obj[0] = args;
26429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26430 if (!SWIG_IsOK(res1)) {
26431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26432 }
26433 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26434 {
26435 PyThreadState* __tstate = wxPyBeginAllowThreads();
26436 delete arg1;
26437
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 resultobj = SWIG_Py_Void();
26442 return resultobj;
26443 fail:
26444 return NULL;
26445 }
26446
26447
26448 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26449 PyObject *resultobj = 0;
26450 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26451 PyObject *arg2 = (PyObject *) 0 ;
26452 void *argp1 = 0 ;
26453 int res1 = 0 ;
26454 PyObject * obj0 = 0 ;
26455 PyObject * obj1 = 0 ;
26456 char * kwnames[] = {
26457 (char *) "self",(char *) "self", NULL
26458 };
26459
26460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26464 }
26465 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26466 arg2 = obj1;
26467 {
26468 PyThreadState* __tstate = wxPyBeginAllowThreads();
26469 (arg1)->SetSelf(arg2);
26470 wxPyEndAllowThreads(__tstate);
26471 if (PyErr_Occurred()) SWIG_fail;
26472 }
26473 resultobj = SWIG_Py_Void();
26474 return resultobj;
26475 fail:
26476 return NULL;
26477 }
26478
26479
26480 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26481 PyObject *resultobj = 0;
26482 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26483 PyObject *result = 0 ;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 PyObject *swig_obj[1] ;
26487
26488 if (!args) SWIG_fail;
26489 swig_obj[0] = args;
26490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26491 if (!SWIG_IsOK(res1)) {
26492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26493 }
26494 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26495 {
26496 PyThreadState* __tstate = wxPyBeginAllowThreads();
26497 result = (PyObject *)(arg1)->GetSelf();
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 resultobj = result;
26502 return resultobj;
26503 fail:
26504 return NULL;
26505 }
26506
26507
26508 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26509 PyObject *obj;
26510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26512 return SWIG_Py_Void();
26513 }
26514
26515 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 return SWIG_Python_InitShadowInstance(args);
26517 }
26518
26519 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26520 PyObject *resultobj = 0;
26521 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26522 int arg2 = (int) 0 ;
26523 wxPyCommandEvent *result = 0 ;
26524 int val1 ;
26525 int ecode1 = 0 ;
26526 int val2 ;
26527 int ecode2 = 0 ;
26528 PyObject * obj0 = 0 ;
26529 PyObject * obj1 = 0 ;
26530 char * kwnames[] = {
26531 (char *) "eventType",(char *) "id", NULL
26532 };
26533
26534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26535 if (obj0) {
26536 ecode1 = SWIG_AsVal_int(obj0, &val1);
26537 if (!SWIG_IsOK(ecode1)) {
26538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26539 }
26540 arg1 = static_cast< wxEventType >(val1);
26541 }
26542 if (obj1) {
26543 ecode2 = SWIG_AsVal_int(obj1, &val2);
26544 if (!SWIG_IsOK(ecode2)) {
26545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26546 }
26547 arg2 = static_cast< int >(val2);
26548 }
26549 {
26550 PyThreadState* __tstate = wxPyBeginAllowThreads();
26551 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26552 wxPyEndAllowThreads(__tstate);
26553 if (PyErr_Occurred()) SWIG_fail;
26554 }
26555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563 PyObject *resultobj = 0;
26564 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26565 void *argp1 = 0 ;
26566 int res1 = 0 ;
26567 PyObject *swig_obj[1] ;
26568
26569 if (!args) SWIG_fail;
26570 swig_obj[0] = args;
26571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26572 if (!SWIG_IsOK(res1)) {
26573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26574 }
26575 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 delete arg1;
26579
26580 wxPyEndAllowThreads(__tstate);
26581 if (PyErr_Occurred()) SWIG_fail;
26582 }
26583 resultobj = SWIG_Py_Void();
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26591 PyObject *resultobj = 0;
26592 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26593 PyObject *arg2 = (PyObject *) 0 ;
26594 void *argp1 = 0 ;
26595 int res1 = 0 ;
26596 PyObject * obj0 = 0 ;
26597 PyObject * obj1 = 0 ;
26598 char * kwnames[] = {
26599 (char *) "self",(char *) "self", NULL
26600 };
26601
26602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26604 if (!SWIG_IsOK(res1)) {
26605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26606 }
26607 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26608 arg2 = obj1;
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 (arg1)->SetSelf(arg2);
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 resultobj = SWIG_Py_Void();
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26623 PyObject *resultobj = 0;
26624 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26625 PyObject *result = 0 ;
26626 void *argp1 = 0 ;
26627 int res1 = 0 ;
26628 PyObject *swig_obj[1] ;
26629
26630 if (!args) SWIG_fail;
26631 swig_obj[0] = args;
26632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26635 }
26636 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26637 {
26638 PyThreadState* __tstate = wxPyBeginAllowThreads();
26639 result = (PyObject *)(arg1)->GetSelf();
26640 wxPyEndAllowThreads(__tstate);
26641 if (PyErr_Occurred()) SWIG_fail;
26642 }
26643 resultobj = result;
26644 return resultobj;
26645 fail:
26646 return NULL;
26647 }
26648
26649
26650 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26651 PyObject *obj;
26652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26653 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26654 return SWIG_Py_Void();
26655 }
26656
26657 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26658 return SWIG_Python_InitShadowInstance(args);
26659 }
26660
26661 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26662 PyObject *resultobj = 0;
26663 wxWindow *arg1 = (wxWindow *) 0 ;
26664 wxDateTime *arg2 = 0 ;
26665 wxEventType arg3 ;
26666 wxDateEvent *result = 0 ;
26667 void *argp1 = 0 ;
26668 int res1 = 0 ;
26669 void *argp2 = 0 ;
26670 int res2 = 0 ;
26671 int val3 ;
26672 int ecode3 = 0 ;
26673 PyObject * obj0 = 0 ;
26674 PyObject * obj1 = 0 ;
26675 PyObject * obj2 = 0 ;
26676 char * kwnames[] = {
26677 (char *) "win",(char *) "dt",(char *) "type", NULL
26678 };
26679
26680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26682 if (!SWIG_IsOK(res1)) {
26683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26684 }
26685 arg1 = reinterpret_cast< wxWindow * >(argp1);
26686 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26687 if (!SWIG_IsOK(res2)) {
26688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26689 }
26690 if (!argp2) {
26691 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26692 }
26693 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26694 ecode3 = SWIG_AsVal_int(obj2, &val3);
26695 if (!SWIG_IsOK(ecode3)) {
26696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26697 }
26698 arg3 = static_cast< wxEventType >(val3);
26699 {
26700 PyThreadState* __tstate = wxPyBeginAllowThreads();
26701 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26702 wxPyEndAllowThreads(__tstate);
26703 if (PyErr_Occurred()) SWIG_fail;
26704 }
26705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26706 return resultobj;
26707 fail:
26708 return NULL;
26709 }
26710
26711
26712 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26713 PyObject *resultobj = 0;
26714 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26715 wxDateTime *result = 0 ;
26716 void *argp1 = 0 ;
26717 int res1 = 0 ;
26718 PyObject *swig_obj[1] ;
26719
26720 if (!args) SWIG_fail;
26721 swig_obj[0] = args;
26722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26723 if (!SWIG_IsOK(res1)) {
26724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26725 }
26726 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26727 {
26728 PyThreadState* __tstate = wxPyBeginAllowThreads();
26729 {
26730 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26731 result = (wxDateTime *) &_result_ref;
26732 }
26733 wxPyEndAllowThreads(__tstate);
26734 if (PyErr_Occurred()) SWIG_fail;
26735 }
26736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26744 PyObject *resultobj = 0;
26745 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26746 wxDateTime *arg2 = 0 ;
26747 void *argp1 = 0 ;
26748 int res1 = 0 ;
26749 void *argp2 = 0 ;
26750 int res2 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 char * kwnames[] = {
26754 (char *) "self",(char *) "date", NULL
26755 };
26756
26757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26759 if (!SWIG_IsOK(res1)) {
26760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26761 }
26762 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26764 if (!SWIG_IsOK(res2)) {
26765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26766 }
26767 if (!argp2) {
26768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26769 }
26770 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26771 {
26772 PyThreadState* __tstate = wxPyBeginAllowThreads();
26773 (arg1)->SetDate((wxDateTime const &)*arg2);
26774 wxPyEndAllowThreads(__tstate);
26775 if (PyErr_Occurred()) SWIG_fail;
26776 }
26777 resultobj = SWIG_Py_Void();
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26785 PyObject *obj;
26786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26787 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26788 return SWIG_Py_Void();
26789 }
26790
26791 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26792 return SWIG_Python_InitShadowInstance(args);
26793 }
26794
26795 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26796 PyObject *resultobj = 0;
26797 wxPyApp *result = 0 ;
26798
26799 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26800 {
26801 PyThreadState* __tstate = wxPyBeginAllowThreads();
26802 result = (wxPyApp *)new_wxPyApp();
26803 wxPyEndAllowThreads(__tstate);
26804 if (PyErr_Occurred()) SWIG_fail;
26805 }
26806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26807 return resultobj;
26808 fail:
26809 return NULL;
26810 }
26811
26812
26813 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26814 PyObject *resultobj = 0;
26815 wxPyApp *arg1 = (wxPyApp *) 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26825 }
26826 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 delete arg1;
26830
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 resultobj = SWIG_Py_Void();
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26842 PyObject *resultobj = 0;
26843 wxPyApp *arg1 = (wxPyApp *) 0 ;
26844 PyObject *arg2 = (PyObject *) 0 ;
26845 PyObject *arg3 = (PyObject *) 0 ;
26846 bool arg4 ;
26847 void *argp1 = 0 ;
26848 int res1 = 0 ;
26849 bool val4 ;
26850 int ecode4 = 0 ;
26851 PyObject * obj0 = 0 ;
26852 PyObject * obj1 = 0 ;
26853 PyObject * obj2 = 0 ;
26854 PyObject * obj3 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26863 }
26864 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26865 arg2 = obj1;
26866 arg3 = obj2;
26867 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26868 if (!SWIG_IsOK(ecode4)) {
26869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26870 }
26871 arg4 = static_cast< bool >(val4);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 resultobj = SWIG_Py_Void();
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26886 PyObject *resultobj = 0;
26887 wxPyApp *arg1 = (wxPyApp *) 0 ;
26888 wxString result;
26889 void *argp1 = 0 ;
26890 int res1 = 0 ;
26891 PyObject *swig_obj[1] ;
26892
26893 if (!args) SWIG_fail;
26894 swig_obj[0] = args;
26895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26896 if (!SWIG_IsOK(res1)) {
26897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26898 }
26899 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26900 {
26901 PyThreadState* __tstate = wxPyBeginAllowThreads();
26902 result = ((wxPyApp const *)arg1)->GetAppName();
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 {
26907 #if wxUSE_UNICODE
26908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26909 #else
26910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26911 #endif
26912 }
26913 return resultobj;
26914 fail:
26915 return NULL;
26916 }
26917
26918
26919 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26920 PyObject *resultobj = 0;
26921 wxPyApp *arg1 = (wxPyApp *) 0 ;
26922 wxString *arg2 = 0 ;
26923 void *argp1 = 0 ;
26924 int res1 = 0 ;
26925 bool temp2 = false ;
26926 PyObject * obj0 = 0 ;
26927 PyObject * obj1 = 0 ;
26928 char * kwnames[] = {
26929 (char *) "self",(char *) "name", NULL
26930 };
26931
26932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26934 if (!SWIG_IsOK(res1)) {
26935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26936 }
26937 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26938 {
26939 arg2 = wxString_in_helper(obj1);
26940 if (arg2 == NULL) SWIG_fail;
26941 temp2 = true;
26942 }
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 (arg1)->SetAppName((wxString const &)*arg2);
26946 wxPyEndAllowThreads(__tstate);
26947 if (PyErr_Occurred()) SWIG_fail;
26948 }
26949 resultobj = SWIG_Py_Void();
26950 {
26951 if (temp2)
26952 delete arg2;
26953 }
26954 return resultobj;
26955 fail:
26956 {
26957 if (temp2)
26958 delete arg2;
26959 }
26960 return NULL;
26961 }
26962
26963
26964 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26965 PyObject *resultobj = 0;
26966 wxPyApp *arg1 = (wxPyApp *) 0 ;
26967 wxString result;
26968 void *argp1 = 0 ;
26969 int res1 = 0 ;
26970 PyObject *swig_obj[1] ;
26971
26972 if (!args) SWIG_fail;
26973 swig_obj[0] = args;
26974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26975 if (!SWIG_IsOK(res1)) {
26976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26977 }
26978 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26979 {
26980 PyThreadState* __tstate = wxPyBeginAllowThreads();
26981 result = ((wxPyApp const *)arg1)->GetClassName();
26982 wxPyEndAllowThreads(__tstate);
26983 if (PyErr_Occurred()) SWIG_fail;
26984 }
26985 {
26986 #if wxUSE_UNICODE
26987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26988 #else
26989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26990 #endif
26991 }
26992 return resultobj;
26993 fail:
26994 return NULL;
26995 }
26996
26997
26998 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26999 PyObject *resultobj = 0;
27000 wxPyApp *arg1 = (wxPyApp *) 0 ;
27001 wxString *arg2 = 0 ;
27002 void *argp1 = 0 ;
27003 int res1 = 0 ;
27004 bool temp2 = false ;
27005 PyObject * obj0 = 0 ;
27006 PyObject * obj1 = 0 ;
27007 char * kwnames[] = {
27008 (char *) "self",(char *) "name", NULL
27009 };
27010
27011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27013 if (!SWIG_IsOK(res1)) {
27014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27015 }
27016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27017 {
27018 arg2 = wxString_in_helper(obj1);
27019 if (arg2 == NULL) SWIG_fail;
27020 temp2 = true;
27021 }
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 (arg1)->SetClassName((wxString const &)*arg2);
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 resultobj = SWIG_Py_Void();
27029 {
27030 if (temp2)
27031 delete arg2;
27032 }
27033 return resultobj;
27034 fail:
27035 {
27036 if (temp2)
27037 delete arg2;
27038 }
27039 return NULL;
27040 }
27041
27042
27043 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27044 PyObject *resultobj = 0;
27045 wxPyApp *arg1 = (wxPyApp *) 0 ;
27046 wxString *result = 0 ;
27047 void *argp1 = 0 ;
27048 int res1 = 0 ;
27049 PyObject *swig_obj[1] ;
27050
27051 if (!args) SWIG_fail;
27052 swig_obj[0] = args;
27053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27054 if (!SWIG_IsOK(res1)) {
27055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27056 }
27057 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 {
27061 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27062 result = (wxString *) &_result_ref;
27063 }
27064 wxPyEndAllowThreads(__tstate);
27065 if (PyErr_Occurred()) SWIG_fail;
27066 }
27067 {
27068 #if wxUSE_UNICODE
27069 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27070 #else
27071 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27072 #endif
27073 }
27074 return resultobj;
27075 fail:
27076 return NULL;
27077 }
27078
27079
27080 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27081 PyObject *resultobj = 0;
27082 wxPyApp *arg1 = (wxPyApp *) 0 ;
27083 wxString *arg2 = 0 ;
27084 void *argp1 = 0 ;
27085 int res1 = 0 ;
27086 bool temp2 = false ;
27087 PyObject * obj0 = 0 ;
27088 PyObject * obj1 = 0 ;
27089 char * kwnames[] = {
27090 (char *) "self",(char *) "name", NULL
27091 };
27092
27093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27095 if (!SWIG_IsOK(res1)) {
27096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27097 }
27098 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27099 {
27100 arg2 = wxString_in_helper(obj1);
27101 if (arg2 == NULL) SWIG_fail;
27102 temp2 = true;
27103 }
27104 {
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 (arg1)->SetVendorName((wxString const &)*arg2);
27107 wxPyEndAllowThreads(__tstate);
27108 if (PyErr_Occurred()) SWIG_fail;
27109 }
27110 resultobj = SWIG_Py_Void();
27111 {
27112 if (temp2)
27113 delete arg2;
27114 }
27115 return resultobj;
27116 fail:
27117 {
27118 if (temp2)
27119 delete arg2;
27120 }
27121 return NULL;
27122 }
27123
27124
27125 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27126 PyObject *resultobj = 0;
27127 wxPyApp *arg1 = (wxPyApp *) 0 ;
27128 wxAppTraits *result = 0 ;
27129 void *argp1 = 0 ;
27130 int res1 = 0 ;
27131 PyObject *swig_obj[1] ;
27132
27133 if (!args) SWIG_fail;
27134 swig_obj[0] = args;
27135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27136 if (!SWIG_IsOK(res1)) {
27137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27138 }
27139 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (wxAppTraits *)(arg1)->GetTraits();
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27147 return resultobj;
27148 fail:
27149 return NULL;
27150 }
27151
27152
27153 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27154 PyObject *resultobj = 0;
27155 wxPyApp *arg1 = (wxPyApp *) 0 ;
27156 void *argp1 = 0 ;
27157 int res1 = 0 ;
27158 PyObject *swig_obj[1] ;
27159
27160 if (!args) SWIG_fail;
27161 swig_obj[0] = args;
27162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27163 if (!SWIG_IsOK(res1)) {
27164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27165 }
27166 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 (arg1)->ProcessPendingEvents();
27170 wxPyEndAllowThreads(__tstate);
27171 if (PyErr_Occurred()) SWIG_fail;
27172 }
27173 resultobj = SWIG_Py_Void();
27174 return resultobj;
27175 fail:
27176 return NULL;
27177 }
27178
27179
27180 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27181 PyObject *resultobj = 0;
27182 wxPyApp *arg1 = (wxPyApp *) 0 ;
27183 bool arg2 = (bool) false ;
27184 bool result;
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 *) "onlyIfNeeded", NULL
27193 };
27194
27195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27197 if (!SWIG_IsOK(res1)) {
27198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27199 }
27200 arg1 = reinterpret_cast< wxPyApp * >(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 '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27205 }
27206 arg2 = static_cast< bool >(val2);
27207 }
27208 {
27209 PyThreadState* __tstate = wxPyBeginAllowThreads();
27210 result = (bool)(arg1)->Yield(arg2);
27211 wxPyEndAllowThreads(__tstate);
27212 if (PyErr_Occurred()) SWIG_fail;
27213 }
27214 {
27215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27216 }
27217 return resultobj;
27218 fail:
27219 return NULL;
27220 }
27221
27222
27223 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27224 PyObject *resultobj = 0;
27225 wxPyApp *arg1 = (wxPyApp *) 0 ;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 PyObject *swig_obj[1] ;
27229
27230 if (!args) SWIG_fail;
27231 swig_obj[0] = args;
27232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27233 if (!SWIG_IsOK(res1)) {
27234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27235 }
27236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 (arg1)->WakeUpIdle();
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 resultobj = SWIG_Py_Void();
27244 return resultobj;
27245 fail:
27246 return NULL;
27247 }
27248
27249
27250 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27251 PyObject *resultobj = 0;
27252 bool result;
27253
27254 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27255 {
27256 PyThreadState* __tstate = wxPyBeginAllowThreads();
27257 result = (bool)wxPyApp::IsMainLoopRunning();
27258 wxPyEndAllowThreads(__tstate);
27259 if (PyErr_Occurred()) SWIG_fail;
27260 }
27261 {
27262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27263 }
27264 return resultobj;
27265 fail:
27266 return NULL;
27267 }
27268
27269
27270 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27271 PyObject *resultobj = 0;
27272 wxPyApp *arg1 = (wxPyApp *) 0 ;
27273 int result;
27274 void *argp1 = 0 ;
27275 int res1 = 0 ;
27276 PyObject *swig_obj[1] ;
27277
27278 if (!args) SWIG_fail;
27279 swig_obj[0] = args;
27280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27281 if (!SWIG_IsOK(res1)) {
27282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27283 }
27284 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27285 {
27286 PyThreadState* __tstate = wxPyBeginAllowThreads();
27287 result = (int)(arg1)->MainLoop();
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_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27299 PyObject *resultobj = 0;
27300 wxPyApp *arg1 = (wxPyApp *) 0 ;
27301 void *argp1 = 0 ;
27302 int res1 = 0 ;
27303 PyObject *swig_obj[1] ;
27304
27305 if (!args) SWIG_fail;
27306 swig_obj[0] = args;
27307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27310 }
27311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 (arg1)->Exit();
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 resultobj = SWIG_Py_Void();
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27326 PyObject *resultobj = 0;
27327 wxPyApp *arg1 = (wxPyApp *) 0 ;
27328 void *argp1 = 0 ;
27329 int res1 = 0 ;
27330 PyObject *swig_obj[1] ;
27331
27332 if (!args) SWIG_fail;
27333 swig_obj[0] = args;
27334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27335 if (!SWIG_IsOK(res1)) {
27336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27337 }
27338 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27339 {
27340 PyThreadState* __tstate = wxPyBeginAllowThreads();
27341 (arg1)->ExitMainLoop();
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 resultobj = SWIG_Py_Void();
27346 return resultobj;
27347 fail:
27348 return NULL;
27349 }
27350
27351
27352 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27353 PyObject *resultobj = 0;
27354 wxPyApp *arg1 = (wxPyApp *) 0 ;
27355 bool result;
27356 void *argp1 = 0 ;
27357 int res1 = 0 ;
27358 PyObject *swig_obj[1] ;
27359
27360 if (!args) SWIG_fail;
27361 swig_obj[0] = args;
27362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27363 if (!SWIG_IsOK(res1)) {
27364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27365 }
27366 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27367 {
27368 PyThreadState* __tstate = wxPyBeginAllowThreads();
27369 result = (bool)(arg1)->Pending();
27370 wxPyEndAllowThreads(__tstate);
27371 if (PyErr_Occurred()) SWIG_fail;
27372 }
27373 {
27374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27375 }
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxPyApp *arg1 = (wxPyApp *) 0 ;
27385 bool result;
27386 void *argp1 = 0 ;
27387 int res1 = 0 ;
27388 PyObject *swig_obj[1] ;
27389
27390 if (!args) SWIG_fail;
27391 swig_obj[0] = args;
27392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27393 if (!SWIG_IsOK(res1)) {
27394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27395 }
27396 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27397 {
27398 PyThreadState* __tstate = wxPyBeginAllowThreads();
27399 result = (bool)(arg1)->Dispatch();
27400 wxPyEndAllowThreads(__tstate);
27401 if (PyErr_Occurred()) SWIG_fail;
27402 }
27403 {
27404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27405 }
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27413 PyObject *resultobj = 0;
27414 wxPyApp *arg1 = (wxPyApp *) 0 ;
27415 bool result;
27416 void *argp1 = 0 ;
27417 int res1 = 0 ;
27418 PyObject *swig_obj[1] ;
27419
27420 if (!args) SWIG_fail;
27421 swig_obj[0] = args;
27422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27423 if (!SWIG_IsOK(res1)) {
27424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27425 }
27426 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = (bool)(arg1)->ProcessIdle();
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27443 PyObject *resultobj = 0;
27444 wxPyApp *arg1 = (wxPyApp *) 0 ;
27445 wxWindow *arg2 = (wxWindow *) 0 ;
27446 wxIdleEvent *arg3 = 0 ;
27447 bool result;
27448 void *argp1 = 0 ;
27449 int res1 = 0 ;
27450 void *argp2 = 0 ;
27451 int res2 = 0 ;
27452 void *argp3 = 0 ;
27453 int res3 = 0 ;
27454 PyObject * obj0 = 0 ;
27455 PyObject * obj1 = 0 ;
27456 PyObject * obj2 = 0 ;
27457 char * kwnames[] = {
27458 (char *) "self",(char *) "win",(char *) "event", NULL
27459 };
27460
27461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27465 }
27466 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27468 if (!SWIG_IsOK(res2)) {
27469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27470 }
27471 arg2 = reinterpret_cast< wxWindow * >(argp2);
27472 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27473 if (!SWIG_IsOK(res3)) {
27474 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27475 }
27476 if (!argp3) {
27477 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27478 }
27479 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27480 {
27481 PyThreadState* __tstate = wxPyBeginAllowThreads();
27482 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 {
27487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27488 }
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27496 PyObject *resultobj = 0;
27497 wxPyApp *arg1 = (wxPyApp *) 0 ;
27498 bool result;
27499 void *argp1 = 0 ;
27500 int res1 = 0 ;
27501 PyObject *swig_obj[1] ;
27502
27503 if (!args) SWIG_fail;
27504 swig_obj[0] = args;
27505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27506 if (!SWIG_IsOK(res1)) {
27507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27508 }
27509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27510 {
27511 PyThreadState* __tstate = wxPyBeginAllowThreads();
27512 result = (bool)((wxPyApp const *)arg1)->IsActive();
27513 wxPyEndAllowThreads(__tstate);
27514 if (PyErr_Occurred()) SWIG_fail;
27515 }
27516 {
27517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27518 }
27519 return resultobj;
27520 fail:
27521 return NULL;
27522 }
27523
27524
27525 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27526 PyObject *resultobj = 0;
27527 wxPyApp *arg1 = (wxPyApp *) 0 ;
27528 wxWindow *arg2 = (wxWindow *) 0 ;
27529 void *argp1 = 0 ;
27530 int res1 = 0 ;
27531 void *argp2 = 0 ;
27532 int res2 = 0 ;
27533 PyObject * obj0 = 0 ;
27534 PyObject * obj1 = 0 ;
27535 char * kwnames[] = {
27536 (char *) "self",(char *) "win", NULL
27537 };
27538
27539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27541 if (!SWIG_IsOK(res1)) {
27542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27543 }
27544 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27546 if (!SWIG_IsOK(res2)) {
27547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27548 }
27549 arg2 = reinterpret_cast< wxWindow * >(argp2);
27550 {
27551 PyThreadState* __tstate = wxPyBeginAllowThreads();
27552 (arg1)->SetTopWindow(arg2);
27553 wxPyEndAllowThreads(__tstate);
27554 if (PyErr_Occurred()) SWIG_fail;
27555 }
27556 resultobj = SWIG_Py_Void();
27557 return resultobj;
27558 fail:
27559 return NULL;
27560 }
27561
27562
27563 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27564 PyObject *resultobj = 0;
27565 wxPyApp *arg1 = (wxPyApp *) 0 ;
27566 wxWindow *result = 0 ;
27567 void *argp1 = 0 ;
27568 int res1 = 0 ;
27569 PyObject *swig_obj[1] ;
27570
27571 if (!args) SWIG_fail;
27572 swig_obj[0] = args;
27573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27574 if (!SWIG_IsOK(res1)) {
27575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27576 }
27577 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27578 {
27579 PyThreadState* __tstate = wxPyBeginAllowThreads();
27580 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = wxPyMake_wxObject(result, (bool)0);
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj = 0;
27595 wxPyApp *arg1 = (wxPyApp *) 0 ;
27596 bool arg2 ;
27597 void *argp1 = 0 ;
27598 int res1 = 0 ;
27599 bool val2 ;
27600 int ecode2 = 0 ;
27601 PyObject * obj0 = 0 ;
27602 PyObject * obj1 = 0 ;
27603 char * kwnames[] = {
27604 (char *) "self",(char *) "flag", NULL
27605 };
27606
27607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27609 if (!SWIG_IsOK(res1)) {
27610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27611 }
27612 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27613 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27614 if (!SWIG_IsOK(ecode2)) {
27615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27616 }
27617 arg2 = static_cast< bool >(val2);
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 (arg1)->SetExitOnFrameDelete(arg2);
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 resultobj = SWIG_Py_Void();
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27632 PyObject *resultobj = 0;
27633 wxPyApp *arg1 = (wxPyApp *) 0 ;
27634 bool result;
27635 void *argp1 = 0 ;
27636 int res1 = 0 ;
27637 PyObject *swig_obj[1] ;
27638
27639 if (!args) SWIG_fail;
27640 swig_obj[0] = args;
27641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27642 if (!SWIG_IsOK(res1)) {
27643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27644 }
27645 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27646 {
27647 PyThreadState* __tstate = wxPyBeginAllowThreads();
27648 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27649 wxPyEndAllowThreads(__tstate);
27650 if (PyErr_Occurred()) SWIG_fail;
27651 }
27652 {
27653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27654 }
27655 return resultobj;
27656 fail:
27657 return NULL;
27658 }
27659
27660
27661 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27662 PyObject *resultobj = 0;
27663 wxPyApp *arg1 = (wxPyApp *) 0 ;
27664 bool arg2 ;
27665 void *argp1 = 0 ;
27666 int res1 = 0 ;
27667 bool val2 ;
27668 int ecode2 = 0 ;
27669 PyObject * obj0 = 0 ;
27670 PyObject * obj1 = 0 ;
27671 char * kwnames[] = {
27672 (char *) "self",(char *) "flag", NULL
27673 };
27674
27675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27677 if (!SWIG_IsOK(res1)) {
27678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27679 }
27680 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27682 if (!SWIG_IsOK(ecode2)) {
27683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27684 }
27685 arg2 = static_cast< bool >(val2);
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 (arg1)->SetUseBestVisual(arg2);
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 resultobj = SWIG_Py_Void();
27693 return resultobj;
27694 fail:
27695 return NULL;
27696 }
27697
27698
27699 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27700 PyObject *resultobj = 0;
27701 wxPyApp *arg1 = (wxPyApp *) 0 ;
27702 bool result;
27703 void *argp1 = 0 ;
27704 int res1 = 0 ;
27705 PyObject *swig_obj[1] ;
27706
27707 if (!args) SWIG_fail;
27708 swig_obj[0] = args;
27709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27710 if (!SWIG_IsOK(res1)) {
27711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27712 }
27713 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 {
27721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27722 }
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 wxPyApp *arg1 = (wxPyApp *) 0 ;
27732 int arg2 ;
27733 void *argp1 = 0 ;
27734 int res1 = 0 ;
27735 int val2 ;
27736 int ecode2 = 0 ;
27737 PyObject * obj0 = 0 ;
27738 PyObject * obj1 = 0 ;
27739 char * kwnames[] = {
27740 (char *) "self",(char *) "mode", NULL
27741 };
27742
27743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27745 if (!SWIG_IsOK(res1)) {
27746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27747 }
27748 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27749 ecode2 = SWIG_AsVal_int(obj1, &val2);
27750 if (!SWIG_IsOK(ecode2)) {
27751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27752 }
27753 arg2 = static_cast< int >(val2);
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 (arg1)->SetPrintMode(arg2);
27757 wxPyEndAllowThreads(__tstate);
27758 if (PyErr_Occurred()) SWIG_fail;
27759 }
27760 resultobj = SWIG_Py_Void();
27761 return resultobj;
27762 fail:
27763 return NULL;
27764 }
27765
27766
27767 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27768 PyObject *resultobj = 0;
27769 wxPyApp *arg1 = (wxPyApp *) 0 ;
27770 int result;
27771 void *argp1 = 0 ;
27772 int res1 = 0 ;
27773 PyObject *swig_obj[1] ;
27774
27775 if (!args) SWIG_fail;
27776 swig_obj[0] = args;
27777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27778 if (!SWIG_IsOK(res1)) {
27779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27780 }
27781 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 resultobj = SWIG_From_int(static_cast< int >(result));
27789 return resultobj;
27790 fail:
27791 return NULL;
27792 }
27793
27794
27795 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27796 PyObject *resultobj = 0;
27797 wxPyApp *arg1 = (wxPyApp *) 0 ;
27798 int arg2 ;
27799 void *argp1 = 0 ;
27800 int res1 = 0 ;
27801 int val2 ;
27802 int ecode2 = 0 ;
27803 PyObject * obj0 = 0 ;
27804 PyObject * obj1 = 0 ;
27805 char * kwnames[] = {
27806 (char *) "self",(char *) "mode", NULL
27807 };
27808
27809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27811 if (!SWIG_IsOK(res1)) {
27812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27813 }
27814 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27815 ecode2 = SWIG_AsVal_int(obj1, &val2);
27816 if (!SWIG_IsOK(ecode2)) {
27817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27818 }
27819 arg2 = static_cast< int >(val2);
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->SetAssertMode(arg2);
27823 wxPyEndAllowThreads(__tstate);
27824 if (PyErr_Occurred()) SWIG_fail;
27825 }
27826 resultobj = SWIG_Py_Void();
27827 return resultobj;
27828 fail:
27829 return NULL;
27830 }
27831
27832
27833 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27834 PyObject *resultobj = 0;
27835 wxPyApp *arg1 = (wxPyApp *) 0 ;
27836 int result;
27837 void *argp1 = 0 ;
27838 int res1 = 0 ;
27839 PyObject *swig_obj[1] ;
27840
27841 if (!args) SWIG_fail;
27842 swig_obj[0] = args;
27843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27846 }
27847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = (int)(arg1)->GetAssertMode();
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 resultobj = SWIG_From_int(static_cast< int >(result));
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27862 PyObject *resultobj = 0;
27863 bool result;
27864
27865 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27874 }
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27882 PyObject *resultobj = 0;
27883 long result;
27884
27885 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = (long)wxPyApp::GetMacAboutMenuItemId();
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_From_long(static_cast< long >(result));
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27900 PyObject *resultobj = 0;
27901 long result;
27902
27903 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27907 wxPyEndAllowThreads(__tstate);
27908 if (PyErr_Occurred()) SWIG_fail;
27909 }
27910 resultobj = SWIG_From_long(static_cast< long >(result));
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27918 PyObject *resultobj = 0;
27919 long result;
27920
27921 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27922 {
27923 PyThreadState* __tstate = wxPyBeginAllowThreads();
27924 result = (long)wxPyApp::GetMacExitMenuItemId();
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 resultobj = SWIG_From_long(static_cast< long >(result));
27929 return resultobj;
27930 fail:
27931 return NULL;
27932 }
27933
27934
27935 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27936 PyObject *resultobj = 0;
27937 wxString result;
27938
27939 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27940 {
27941 PyThreadState* __tstate = wxPyBeginAllowThreads();
27942 result = wxPyApp::GetMacHelpMenuTitleName();
27943 wxPyEndAllowThreads(__tstate);
27944 if (PyErr_Occurred()) SWIG_fail;
27945 }
27946 {
27947 #if wxUSE_UNICODE
27948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27949 #else
27950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27951 #endif
27952 }
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj = 0;
27961 bool arg1 ;
27962 bool val1 ;
27963 int ecode1 = 0 ;
27964 PyObject * obj0 = 0 ;
27965 char * kwnames[] = {
27966 (char *) "val", NULL
27967 };
27968
27969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27970 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27971 if (!SWIG_IsOK(ecode1)) {
27972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27973 }
27974 arg1 = static_cast< bool >(val1);
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 resultobj = SWIG_Py_Void();
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj = 0;
27990 long arg1 ;
27991 long val1 ;
27992 int ecode1 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 char * kwnames[] = {
27995 (char *) "val", NULL
27996 };
27997
27998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27999 ecode1 = SWIG_AsVal_long(obj0, &val1);
28000 if (!SWIG_IsOK(ecode1)) {
28001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28002 }
28003 arg1 = static_cast< long >(val1);
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 wxPyApp::SetMacAboutMenuItemId(arg1);
28007 wxPyEndAllowThreads(__tstate);
28008 if (PyErr_Occurred()) SWIG_fail;
28009 }
28010 resultobj = SWIG_Py_Void();
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28018 PyObject *resultobj = 0;
28019 long arg1 ;
28020 long val1 ;
28021 int ecode1 = 0 ;
28022 PyObject * obj0 = 0 ;
28023 char * kwnames[] = {
28024 (char *) "val", NULL
28025 };
28026
28027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28028 ecode1 = SWIG_AsVal_long(obj0, &val1);
28029 if (!SWIG_IsOK(ecode1)) {
28030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28031 }
28032 arg1 = static_cast< long >(val1);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 long arg1 ;
28049 long val1 ;
28050 int ecode1 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 char * kwnames[] = {
28053 (char *) "val", NULL
28054 };
28055
28056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28057 ecode1 = SWIG_AsVal_long(obj0, &val1);
28058 if (!SWIG_IsOK(ecode1)) {
28059 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28060 }
28061 arg1 = static_cast< long >(val1);
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 wxPyApp::SetMacExitMenuItemId(arg1);
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_Py_Void();
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj = 0;
28077 wxString *arg1 = 0 ;
28078 bool temp1 = false ;
28079 PyObject * obj0 = 0 ;
28080 char * kwnames[] = {
28081 (char *) "val", NULL
28082 };
28083
28084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28085 {
28086 arg1 = wxString_in_helper(obj0);
28087 if (arg1 == NULL) SWIG_fail;
28088 temp1 = true;
28089 }
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_Py_Void();
28097 {
28098 if (temp1)
28099 delete arg1;
28100 }
28101 return resultobj;
28102 fail:
28103 {
28104 if (temp1)
28105 delete arg1;
28106 }
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28112 PyObject *resultobj = 0;
28113 wxPyApp *arg1 = (wxPyApp *) 0 ;
28114 void *argp1 = 0 ;
28115 int res1 = 0 ;
28116 PyObject *swig_obj[1] ;
28117
28118 if (!args) SWIG_fail;
28119 swig_obj[0] = args;
28120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28121 if (!SWIG_IsOK(res1)) {
28122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28123 }
28124 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 (arg1)->_BootstrapApp();
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 resultobj = SWIG_Py_Void();
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28139 PyObject *resultobj = 0;
28140 int result;
28141
28142 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 result = (int)wxPyApp_GetComCtl32Version();
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 resultobj = SWIG_From_int(static_cast< int >(result));
28150 return resultobj;
28151 fail:
28152 return NULL;
28153 }
28154
28155
28156 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28157 PyObject *obj;
28158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28160 return SWIG_Py_Void();
28161 }
28162
28163 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28164 return SWIG_Python_InitShadowInstance(args);
28165 }
28166
28167 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169
28170 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28171 {
28172 PyThreadState* __tstate = wxPyBeginAllowThreads();
28173 wxExit();
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 resultobj = SWIG_Py_Void();
28178 return resultobj;
28179 fail:
28180 return NULL;
28181 }
28182
28183
28184 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28185 PyObject *resultobj = 0;
28186 bool result;
28187
28188 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 result = (bool)wxYield();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 {
28196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28197 }
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28205 PyObject *resultobj = 0;
28206 bool result;
28207
28208 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28209 {
28210 PyThreadState* __tstate = wxPyBeginAllowThreads();
28211 result = (bool)wxYieldIfNeeded();
28212 wxPyEndAllowThreads(__tstate);
28213 if (PyErr_Occurred()) SWIG_fail;
28214 }
28215 {
28216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28217 }
28218 return resultobj;
28219 fail:
28220 return NULL;
28221 }
28222
28223
28224 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28225 PyObject *resultobj = 0;
28226 wxWindow *arg1 = (wxWindow *) NULL ;
28227 bool arg2 = (bool) false ;
28228 bool result;
28229 void *argp1 = 0 ;
28230 int res1 = 0 ;
28231 bool val2 ;
28232 int ecode2 = 0 ;
28233 PyObject * obj0 = 0 ;
28234 PyObject * obj1 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "win",(char *) "onlyIfNeeded", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28240 if (obj0) {
28241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28242 if (!SWIG_IsOK(res1)) {
28243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28244 }
28245 arg1 = reinterpret_cast< wxWindow * >(argp1);
28246 }
28247 if (obj1) {
28248 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28249 if (!SWIG_IsOK(ecode2)) {
28250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28251 }
28252 arg2 = static_cast< bool >(val2);
28253 }
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 result = (bool)wxSafeYield(arg1,arg2);
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 {
28261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28262 }
28263 return resultobj;
28264 fail:
28265 return NULL;
28266 }
28267
28268
28269 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28270 PyObject *resultobj = 0;
28271
28272 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28273 {
28274 PyThreadState* __tstate = wxPyBeginAllowThreads();
28275 wxWakeUpIdle();
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 resultobj = SWIG_Py_Void();
28280 return resultobj;
28281 fail:
28282 return NULL;
28283 }
28284
28285
28286 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28287 PyObject *resultobj = 0;
28288 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28289 wxEvent *arg2 = 0 ;
28290 void *argp1 = 0 ;
28291 int res1 = 0 ;
28292 void *argp2 = 0 ;
28293 int res2 = 0 ;
28294 PyObject * obj0 = 0 ;
28295 PyObject * obj1 = 0 ;
28296 char * kwnames[] = {
28297 (char *) "dest",(char *) "event", NULL
28298 };
28299
28300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28304 }
28305 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28306 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28307 if (!SWIG_IsOK(res2)) {
28308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28309 }
28310 if (!argp2) {
28311 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28312 }
28313 arg2 = reinterpret_cast< wxEvent * >(argp2);
28314 {
28315 PyThreadState* __tstate = wxPyBeginAllowThreads();
28316 wxPostEvent(arg1,*arg2);
28317 wxPyEndAllowThreads(__tstate);
28318 if (PyErr_Occurred()) SWIG_fail;
28319 }
28320 resultobj = SWIG_Py_Void();
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28328 PyObject *resultobj = 0;
28329
28330 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28331 {
28332 PyThreadState* __tstate = wxPyBeginAllowThreads();
28333 wxApp_CleanUp();
28334 wxPyEndAllowThreads(__tstate);
28335 if (PyErr_Occurred()) SWIG_fail;
28336 }
28337 resultobj = SWIG_Py_Void();
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 wxPyApp *result = 0 ;
28347
28348 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28349 {
28350 PyThreadState* __tstate = wxPyBeginAllowThreads();
28351 result = (wxPyApp *)wxPyGetApp();
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = wxPyMake_wxObject(result, 0);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 char *arg1 = (char *) 0 ;
28367 int res1 ;
28368 char *buf1 = 0 ;
28369 int alloc1 = 0 ;
28370 PyObject * obj0 = 0 ;
28371 char * kwnames[] = {
28372 (char *) "encoding", NULL
28373 };
28374
28375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28376 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28377 if (!SWIG_IsOK(res1)) {
28378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28379 }
28380 arg1 = buf1;
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 wxSetDefaultPyEncoding((char const *)arg1);
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 resultobj = SWIG_Py_Void();
28388 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28389 return resultobj;
28390 fail:
28391 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28392 return NULL;
28393 }
28394
28395
28396 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28397 PyObject *resultobj = 0;
28398 char *result = 0 ;
28399
28400 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 result = (char *)wxGetDefaultPyEncoding();
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = SWIG_FromCharPtr(result);
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 PyObject *resultobj = 0;
28416 wxEventLoop *result = 0 ;
28417
28418 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 result = (wxEventLoop *)new wxEventLoop();
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28433 PyObject *resultobj = 0;
28434 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28435 void *argp1 = 0 ;
28436 int res1 = 0 ;
28437 PyObject *swig_obj[1] ;
28438
28439 if (!args) SWIG_fail;
28440 swig_obj[0] = args;
28441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28442 if (!SWIG_IsOK(res1)) {
28443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28444 }
28445 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 delete arg1;
28449
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 resultobj = SWIG_Py_Void();
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28461 PyObject *resultobj = 0;
28462 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28463 int result;
28464 void *argp1 = 0 ;
28465 int res1 = 0 ;
28466 PyObject *swig_obj[1] ;
28467
28468 if (!args) SWIG_fail;
28469 swig_obj[0] = args;
28470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28471 if (!SWIG_IsOK(res1)) {
28472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28473 }
28474 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = (int)(arg1)->Run();
28478 wxPyEndAllowThreads(__tstate);
28479 if (PyErr_Occurred()) SWIG_fail;
28480 }
28481 resultobj = SWIG_From_int(static_cast< int >(result));
28482 return resultobj;
28483 fail:
28484 return NULL;
28485 }
28486
28487
28488 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28489 PyObject *resultobj = 0;
28490 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28491 int arg2 = (int) 0 ;
28492 void *argp1 = 0 ;
28493 int res1 = 0 ;
28494 int val2 ;
28495 int ecode2 = 0 ;
28496 PyObject * obj0 = 0 ;
28497 PyObject * obj1 = 0 ;
28498 char * kwnames[] = {
28499 (char *) "self",(char *) "rc", NULL
28500 };
28501
28502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28504 if (!SWIG_IsOK(res1)) {
28505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28506 }
28507 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28508 if (obj1) {
28509 ecode2 = SWIG_AsVal_int(obj1, &val2);
28510 if (!SWIG_IsOK(ecode2)) {
28511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28512 }
28513 arg2 = static_cast< int >(val2);
28514 }
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 (arg1)->Exit(arg2);
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 resultobj = SWIG_Py_Void();
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28531 bool result;
28532 void *argp1 = 0 ;
28533 int res1 = 0 ;
28534 PyObject *swig_obj[1] ;
28535
28536 if (!args) SWIG_fail;
28537 swig_obj[0] = args;
28538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28539 if (!SWIG_IsOK(res1)) {
28540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28541 }
28542 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)((wxEventLoop const *)arg1)->Pending();
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28551 }
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *resultobj = 0;
28560 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28561 bool result;
28562 void *argp1 = 0 ;
28563 int res1 = 0 ;
28564 PyObject *swig_obj[1] ;
28565
28566 if (!args) SWIG_fail;
28567 swig_obj[0] = args;
28568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28569 if (!SWIG_IsOK(res1)) {
28570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28571 }
28572 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 result = (bool)(arg1)->Dispatch();
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 {
28580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28581 }
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28591 bool result;
28592 void *argp1 = 0 ;
28593 int res1 = 0 ;
28594 PyObject *swig_obj[1] ;
28595
28596 if (!args) SWIG_fail;
28597 swig_obj[0] = args;
28598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28601 }
28602 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 PyObject *resultobj = 0;
28620 wxEventLoop *result = 0 ;
28621
28622 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28623 {
28624 PyThreadState* __tstate = wxPyBeginAllowThreads();
28625 result = (wxEventLoop *)wxEventLoop::GetActive();
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28637 PyObject *resultobj = 0;
28638 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28639 void *argp1 = 0 ;
28640 int res1 = 0 ;
28641 PyObject * obj0 = 0 ;
28642 char * kwnames[] = {
28643 (char *) "loop", NULL
28644 };
28645
28646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28648 if (!SWIG_IsOK(res1)) {
28649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28650 }
28651 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28652 {
28653 PyThreadState* __tstate = wxPyBeginAllowThreads();
28654 wxEventLoop::SetActive(arg1);
28655 wxPyEndAllowThreads(__tstate);
28656 if (PyErr_Occurred()) SWIG_fail;
28657 }
28658 resultobj = SWIG_Py_Void();
28659 return resultobj;
28660 fail:
28661 return NULL;
28662 }
28663
28664
28665 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28666 PyObject *obj;
28667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28668 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28669 return SWIG_Py_Void();
28670 }
28671
28672 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28673 return SWIG_Python_InitShadowInstance(args);
28674 }
28675
28676 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28677 PyObject *resultobj = 0;
28678 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28679 wxEventLoopActivator *result = 0 ;
28680 void *argp1 = 0 ;
28681 int res1 = 0 ;
28682 PyObject * obj0 = 0 ;
28683 char * kwnames[] = {
28684 (char *) "evtLoop", NULL
28685 };
28686
28687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28689 if (!SWIG_IsOK(res1)) {
28690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28691 }
28692 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28693 {
28694 PyThreadState* __tstate = wxPyBeginAllowThreads();
28695 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28696 wxPyEndAllowThreads(__tstate);
28697 if (PyErr_Occurred()) SWIG_fail;
28698 }
28699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28700 return resultobj;
28701 fail:
28702 return NULL;
28703 }
28704
28705
28706 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28707 PyObject *resultobj = 0;
28708 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28709 void *argp1 = 0 ;
28710 int res1 = 0 ;
28711 PyObject *swig_obj[1] ;
28712
28713 if (!args) SWIG_fail;
28714 swig_obj[0] = args;
28715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28716 if (!SWIG_IsOK(res1)) {
28717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28718 }
28719 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28720 {
28721 PyThreadState* __tstate = wxPyBeginAllowThreads();
28722 delete arg1;
28723
28724 wxPyEndAllowThreads(__tstate);
28725 if (PyErr_Occurred()) SWIG_fail;
28726 }
28727 resultobj = SWIG_Py_Void();
28728 return resultobj;
28729 fail:
28730 return NULL;
28731 }
28732
28733
28734 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28735 PyObject *obj;
28736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28737 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28738 return SWIG_Py_Void();
28739 }
28740
28741 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28742 return SWIG_Python_InitShadowInstance(args);
28743 }
28744
28745 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28746 PyObject *resultobj = 0;
28747 int arg1 = (int) 0 ;
28748 int arg2 = (int) 0 ;
28749 int arg3 = (int) 0 ;
28750 wxAcceleratorEntry *result = 0 ;
28751 int val1 ;
28752 int ecode1 = 0 ;
28753 int val2 ;
28754 int ecode2 = 0 ;
28755 int val3 ;
28756 int ecode3 = 0 ;
28757 PyObject * obj0 = 0 ;
28758 PyObject * obj1 = 0 ;
28759 PyObject * obj2 = 0 ;
28760 char * kwnames[] = {
28761 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28762 };
28763
28764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28765 if (obj0) {
28766 ecode1 = SWIG_AsVal_int(obj0, &val1);
28767 if (!SWIG_IsOK(ecode1)) {
28768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28769 }
28770 arg1 = static_cast< int >(val1);
28771 }
28772 if (obj1) {
28773 ecode2 = SWIG_AsVal_int(obj1, &val2);
28774 if (!SWIG_IsOK(ecode2)) {
28775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28776 }
28777 arg2 = static_cast< int >(val2);
28778 }
28779 if (obj2) {
28780 ecode3 = SWIG_AsVal_int(obj2, &val3);
28781 if (!SWIG_IsOK(ecode3)) {
28782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28783 }
28784 arg3 = static_cast< int >(val3);
28785 }
28786 {
28787 PyThreadState* __tstate = wxPyBeginAllowThreads();
28788 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28789 wxPyEndAllowThreads(__tstate);
28790 if (PyErr_Occurred()) SWIG_fail;
28791 }
28792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28793 return resultobj;
28794 fail:
28795 return NULL;
28796 }
28797
28798
28799 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28800 PyObject *resultobj = 0;
28801 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28802 void *argp1 = 0 ;
28803 int res1 = 0 ;
28804 PyObject *swig_obj[1] ;
28805
28806 if (!args) SWIG_fail;
28807 swig_obj[0] = args;
28808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28809 if (!SWIG_IsOK(res1)) {
28810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28811 }
28812 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 delete arg1;
28816
28817 wxPyEndAllowThreads(__tstate);
28818 if (PyErr_Occurred()) SWIG_fail;
28819 }
28820 resultobj = SWIG_Py_Void();
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28828 PyObject *resultobj = 0;
28829 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28830 int arg2 ;
28831 int arg3 ;
28832 int arg4 ;
28833 void *argp1 = 0 ;
28834 int res1 = 0 ;
28835 int val2 ;
28836 int ecode2 = 0 ;
28837 int val3 ;
28838 int ecode3 = 0 ;
28839 int val4 ;
28840 int ecode4 = 0 ;
28841 PyObject * obj0 = 0 ;
28842 PyObject * obj1 = 0 ;
28843 PyObject * obj2 = 0 ;
28844 PyObject * obj3 = 0 ;
28845 char * kwnames[] = {
28846 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28847 };
28848
28849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28851 if (!SWIG_IsOK(res1)) {
28852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28853 }
28854 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28855 ecode2 = SWIG_AsVal_int(obj1, &val2);
28856 if (!SWIG_IsOK(ecode2)) {
28857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28858 }
28859 arg2 = static_cast< int >(val2);
28860 ecode3 = SWIG_AsVal_int(obj2, &val3);
28861 if (!SWIG_IsOK(ecode3)) {
28862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28863 }
28864 arg3 = static_cast< int >(val3);
28865 ecode4 = SWIG_AsVal_int(obj3, &val4);
28866 if (!SWIG_IsOK(ecode4)) {
28867 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28868 }
28869 arg4 = static_cast< int >(val4);
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 (arg1)->Set(arg2,arg3,arg4);
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 resultobj = SWIG_Py_Void();
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28884 PyObject *resultobj = 0;
28885 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28886 int result;
28887 void *argp1 = 0 ;
28888 int res1 = 0 ;
28889 PyObject *swig_obj[1] ;
28890
28891 if (!args) SWIG_fail;
28892 swig_obj[0] = args;
28893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28894 if (!SWIG_IsOK(res1)) {
28895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28896 }
28897 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = (int)(arg1)->GetFlags();
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_From_int(static_cast< int >(result));
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28912 PyObject *resultobj = 0;
28913 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28914 int result;
28915 void *argp1 = 0 ;
28916 int res1 = 0 ;
28917 PyObject *swig_obj[1] ;
28918
28919 if (!args) SWIG_fail;
28920 swig_obj[0] = args;
28921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28922 if (!SWIG_IsOK(res1)) {
28923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28924 }
28925 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28926 {
28927 PyThreadState* __tstate = wxPyBeginAllowThreads();
28928 result = (int)(arg1)->GetKeyCode();
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_From_int(static_cast< int >(result));
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28942 int result;
28943 void *argp1 = 0 ;
28944 int res1 = 0 ;
28945 PyObject *swig_obj[1] ;
28946
28947 if (!args) SWIG_fail;
28948 swig_obj[0] = args;
28949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28952 }
28953 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (int)(arg1)->GetCommand();
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_From_int(static_cast< int >(result));
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28968 PyObject *obj;
28969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28970 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28971 return SWIG_Py_Void();
28972 }
28973
28974 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28975 return SWIG_Python_InitShadowInstance(args);
28976 }
28977
28978 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28979 PyObject *resultobj = 0;
28980 int arg1 ;
28981 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28982 wxAcceleratorTable *result = 0 ;
28983 PyObject * obj0 = 0 ;
28984 char * kwnames[] = {
28985 (char *) "n", NULL
28986 };
28987
28988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28989 {
28990 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28991 if (arg2) arg1 = PyList_Size(obj0);
28992 else arg1 = 0;
28993 }
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29008 PyObject *resultobj = 0;
29009 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29010 void *argp1 = 0 ;
29011 int res1 = 0 ;
29012 PyObject *swig_obj[1] ;
29013
29014 if (!args) SWIG_fail;
29015 swig_obj[0] = args;
29016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29017 if (!SWIG_IsOK(res1)) {
29018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29019 }
29020 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29021 {
29022 PyThreadState* __tstate = wxPyBeginAllowThreads();
29023 delete arg1;
29024
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 resultobj = SWIG_Py_Void();
29029 return resultobj;
29030 fail:
29031 return NULL;
29032 }
29033
29034
29035 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29036 PyObject *resultobj = 0;
29037 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29038 bool result;
29039 void *argp1 = 0 ;
29040 int res1 = 0 ;
29041 PyObject *swig_obj[1] ;
29042
29043 if (!args) SWIG_fail;
29044 swig_obj[0] = args;
29045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29046 if (!SWIG_IsOK(res1)) {
29047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29048 }
29049 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29050 {
29051 PyThreadState* __tstate = wxPyBeginAllowThreads();
29052 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 {
29057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29058 }
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29066 PyObject *obj;
29067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29068 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29069 return SWIG_Py_Void();
29070 }
29071
29072 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29073 return SWIG_Python_InitShadowInstance(args);
29074 }
29075
29076 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29077 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29078 return 1;
29079 }
29080
29081
29082 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29083 PyObject *pyobj = 0;
29084
29085 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29086 return pyobj;
29087 }
29088
29089
29090 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29091 PyObject *resultobj = 0;
29092 wxString *arg1 = 0 ;
29093 wxAcceleratorEntry *result = 0 ;
29094 bool temp1 = false ;
29095 PyObject * obj0 = 0 ;
29096 char * kwnames[] = {
29097 (char *) "label", NULL
29098 };
29099
29100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29101 {
29102 arg1 = wxString_in_helper(obj0);
29103 if (arg1 == NULL) SWIG_fail;
29104 temp1 = true;
29105 }
29106 {
29107 PyThreadState* __tstate = wxPyBeginAllowThreads();
29108 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29109 wxPyEndAllowThreads(__tstate);
29110 if (PyErr_Occurred()) SWIG_fail;
29111 }
29112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29113 {
29114 if (temp1)
29115 delete arg1;
29116 }
29117 return resultobj;
29118 fail:
29119 {
29120 if (temp1)
29121 delete arg1;
29122 }
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN int PanelNameStr_set(PyObject *) {
29128 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29129 return 1;
29130 }
29131
29132
29133 SWIGINTERN PyObject *PanelNameStr_get(void) {
29134 PyObject *pyobj = 0;
29135
29136 {
29137 #if wxUSE_UNICODE
29138 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29139 #else
29140 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29141 #endif
29142 }
29143 return pyobj;
29144 }
29145
29146
29147 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29148 PyObject *resultobj = 0;
29149 wxVisualAttributes *result = 0 ;
29150
29151 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 result = (wxVisualAttributes *)new_wxVisualAttributes();
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 PyObject *resultobj = 0;
29167 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29168 void *argp1 = 0 ;
29169 int res1 = 0 ;
29170 PyObject *swig_obj[1] ;
29171
29172 if (!args) SWIG_fail;
29173 swig_obj[0] = args;
29174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29177 }
29178 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 delete_wxVisualAttributes(arg1);
29182
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 resultobj = SWIG_Py_Void();
29187 return resultobj;
29188 fail:
29189 return NULL;
29190 }
29191
29192
29193 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29194 PyObject *resultobj = 0;
29195 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29196 wxFont *arg2 = (wxFont *) 0 ;
29197 void *argp1 = 0 ;
29198 int res1 = 0 ;
29199 void *argp2 = 0 ;
29200 int res2 = 0 ;
29201 PyObject *swig_obj[2] ;
29202
29203 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29205 if (!SWIG_IsOK(res1)) {
29206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29207 }
29208 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29209 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29210 if (!SWIG_IsOK(res2)) {
29211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29212 }
29213 arg2 = reinterpret_cast< wxFont * >(argp2);
29214 if (arg1) (arg1)->font = *arg2;
29215
29216 resultobj = SWIG_Py_Void();
29217 return resultobj;
29218 fail:
29219 return NULL;
29220 }
29221
29222
29223 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 PyObject *resultobj = 0;
29225 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29226 wxFont *result = 0 ;
29227 void *argp1 = 0 ;
29228 int res1 = 0 ;
29229 PyObject *swig_obj[1] ;
29230
29231 if (!args) SWIG_fail;
29232 swig_obj[0] = args;
29233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29234 if (!SWIG_IsOK(res1)) {
29235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29236 }
29237 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29238 result = (wxFont *)& ((arg1)->font);
29239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29240 return resultobj;
29241 fail:
29242 return NULL;
29243 }
29244
29245
29246 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29247 PyObject *resultobj = 0;
29248 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29249 wxColour *arg2 = (wxColour *) 0 ;
29250 void *argp1 = 0 ;
29251 int res1 = 0 ;
29252 void *argp2 = 0 ;
29253 int res2 = 0 ;
29254 PyObject *swig_obj[2] ;
29255
29256 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29258 if (!SWIG_IsOK(res1)) {
29259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29260 }
29261 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29262 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29263 if (!SWIG_IsOK(res2)) {
29264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29265 }
29266 arg2 = reinterpret_cast< wxColour * >(argp2);
29267 if (arg1) (arg1)->colFg = *arg2;
29268
29269 resultobj = SWIG_Py_Void();
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29277 PyObject *resultobj = 0;
29278 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29279 wxColour *result = 0 ;
29280 void *argp1 = 0 ;
29281 int res1 = 0 ;
29282 PyObject *swig_obj[1] ;
29283
29284 if (!args) SWIG_fail;
29285 swig_obj[0] = args;
29286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29287 if (!SWIG_IsOK(res1)) {
29288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29289 }
29290 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29291 result = (wxColour *)& ((arg1)->colFg);
29292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29293 return resultobj;
29294 fail:
29295 return NULL;
29296 }
29297
29298
29299 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29300 PyObject *resultobj = 0;
29301 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29302 wxColour *arg2 = (wxColour *) 0 ;
29303 void *argp1 = 0 ;
29304 int res1 = 0 ;
29305 void *argp2 = 0 ;
29306 int res2 = 0 ;
29307 PyObject *swig_obj[2] ;
29308
29309 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29313 }
29314 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29315 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29316 if (!SWIG_IsOK(res2)) {
29317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29318 }
29319 arg2 = reinterpret_cast< wxColour * >(argp2);
29320 if (arg1) (arg1)->colBg = *arg2;
29321
29322 resultobj = SWIG_Py_Void();
29323 return resultobj;
29324 fail:
29325 return NULL;
29326 }
29327
29328
29329 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29330 PyObject *resultobj = 0;
29331 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29332 wxColour *result = 0 ;
29333 void *argp1 = 0 ;
29334 int res1 = 0 ;
29335 PyObject *swig_obj[1] ;
29336
29337 if (!args) SWIG_fail;
29338 swig_obj[0] = args;
29339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29340 if (!SWIG_IsOK(res1)) {
29341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29342 }
29343 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29344 result = (wxColour *)& ((arg1)->colBg);
29345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29346 return resultobj;
29347 fail:
29348 return NULL;
29349 }
29350
29351
29352 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29353 PyObject *obj;
29354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29355 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29356 return SWIG_Py_Void();
29357 }
29358
29359 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29360 return SWIG_Python_InitShadowInstance(args);
29361 }
29362
29363 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29364 PyObject *resultobj = 0;
29365 wxWindow *arg1 = (wxWindow *) 0 ;
29366 int arg2 = (int) (int)-1 ;
29367 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29368 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29369 wxSize const &arg4_defvalue = wxDefaultSize ;
29370 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29371 long arg5 = (long) 0 ;
29372 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29373 wxString *arg6 = (wxString *) &arg6_defvalue ;
29374 wxWindow *result = 0 ;
29375 void *argp1 = 0 ;
29376 int res1 = 0 ;
29377 int val2 ;
29378 int ecode2 = 0 ;
29379 wxPoint temp3 ;
29380 wxSize temp4 ;
29381 long val5 ;
29382 int ecode5 = 0 ;
29383 bool temp6 = false ;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 PyObject * obj2 = 0 ;
29387 PyObject * obj3 = 0 ;
29388 PyObject * obj4 = 0 ;
29389 PyObject * obj5 = 0 ;
29390 char * kwnames[] = {
29391 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29392 };
29393
29394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29396 if (!SWIG_IsOK(res1)) {
29397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29398 }
29399 arg1 = reinterpret_cast< wxWindow * >(argp1);
29400 if (obj1) {
29401 ecode2 = SWIG_AsVal_int(obj1, &val2);
29402 if (!SWIG_IsOK(ecode2)) {
29403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29404 }
29405 arg2 = static_cast< int >(val2);
29406 }
29407 if (obj2) {
29408 {
29409 arg3 = &temp3;
29410 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29411 }
29412 }
29413 if (obj3) {
29414 {
29415 arg4 = &temp4;
29416 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29417 }
29418 }
29419 if (obj4) {
29420 ecode5 = SWIG_AsVal_long(obj4, &val5);
29421 if (!SWIG_IsOK(ecode5)) {
29422 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29423 }
29424 arg5 = static_cast< long >(val5);
29425 }
29426 if (obj5) {
29427 {
29428 arg6 = wxString_in_helper(obj5);
29429 if (arg6 == NULL) SWIG_fail;
29430 temp6 = true;
29431 }
29432 }
29433 {
29434 if (!wxPyCheckForApp()) SWIG_fail;
29435 PyThreadState* __tstate = wxPyBeginAllowThreads();
29436 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29437 wxPyEndAllowThreads(__tstate);
29438 if (PyErr_Occurred()) SWIG_fail;
29439 }
29440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29441 {
29442 if (temp6)
29443 delete arg6;
29444 }
29445 return resultobj;
29446 fail:
29447 {
29448 if (temp6)
29449 delete arg6;
29450 }
29451 return NULL;
29452 }
29453
29454
29455 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29456 PyObject *resultobj = 0;
29457 wxWindow *result = 0 ;
29458
29459 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29460 {
29461 if (!wxPyCheckForApp()) SWIG_fail;
29462 PyThreadState* __tstate = wxPyBeginAllowThreads();
29463 result = (wxWindow *)new wxWindow();
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 wxWindow *arg1 = (wxWindow *) 0 ;
29477 wxWindow *arg2 = (wxWindow *) 0 ;
29478 int arg3 = (int) (int)-1 ;
29479 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29480 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29481 wxSize const &arg5_defvalue = wxDefaultSize ;
29482 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29483 long arg6 = (long) 0 ;
29484 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29485 wxString *arg7 = (wxString *) &arg7_defvalue ;
29486 bool result;
29487 void *argp1 = 0 ;
29488 int res1 = 0 ;
29489 void *argp2 = 0 ;
29490 int res2 = 0 ;
29491 int val3 ;
29492 int ecode3 = 0 ;
29493 wxPoint temp4 ;
29494 wxSize temp5 ;
29495 long val6 ;
29496 int ecode6 = 0 ;
29497 bool temp7 = false ;
29498 PyObject * obj0 = 0 ;
29499 PyObject * obj1 = 0 ;
29500 PyObject * obj2 = 0 ;
29501 PyObject * obj3 = 0 ;
29502 PyObject * obj4 = 0 ;
29503 PyObject * obj5 = 0 ;
29504 PyObject * obj6 = 0 ;
29505 char * kwnames[] = {
29506 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29507 };
29508
29509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29511 if (!SWIG_IsOK(res1)) {
29512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29513 }
29514 arg1 = reinterpret_cast< wxWindow * >(argp1);
29515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29516 if (!SWIG_IsOK(res2)) {
29517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29518 }
29519 arg2 = reinterpret_cast< wxWindow * >(argp2);
29520 if (obj2) {
29521 ecode3 = SWIG_AsVal_int(obj2, &val3);
29522 if (!SWIG_IsOK(ecode3)) {
29523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29524 }
29525 arg3 = static_cast< int >(val3);
29526 }
29527 if (obj3) {
29528 {
29529 arg4 = &temp4;
29530 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29531 }
29532 }
29533 if (obj4) {
29534 {
29535 arg5 = &temp5;
29536 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29537 }
29538 }
29539 if (obj5) {
29540 ecode6 = SWIG_AsVal_long(obj5, &val6);
29541 if (!SWIG_IsOK(ecode6)) {
29542 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29543 }
29544 arg6 = static_cast< long >(val6);
29545 }
29546 if (obj6) {
29547 {
29548 arg7 = wxString_in_helper(obj6);
29549 if (arg7 == NULL) SWIG_fail;
29550 temp7 = true;
29551 }
29552 }
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29561 }
29562 {
29563 if (temp7)
29564 delete arg7;
29565 }
29566 return resultobj;
29567 fail:
29568 {
29569 if (temp7)
29570 delete arg7;
29571 }
29572 return NULL;
29573 }
29574
29575
29576 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29577 PyObject *resultobj = 0;
29578 wxWindow *arg1 = (wxWindow *) 0 ;
29579 bool arg2 = (bool) false ;
29580 bool result;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 bool val2 ;
29584 int ecode2 = 0 ;
29585 PyObject * obj0 = 0 ;
29586 PyObject * obj1 = 0 ;
29587 char * kwnames[] = {
29588 (char *) "self",(char *) "force", NULL
29589 };
29590
29591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29593 if (!SWIG_IsOK(res1)) {
29594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29595 }
29596 arg1 = reinterpret_cast< wxWindow * >(argp1);
29597 if (obj1) {
29598 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29599 if (!SWIG_IsOK(ecode2)) {
29600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29601 }
29602 arg2 = static_cast< bool >(val2);
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (bool)(arg1)->Close(arg2);
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29612 }
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29620 PyObject *resultobj = 0;
29621 wxWindow *arg1 = (wxWindow *) 0 ;
29622 bool result;
29623 void *argp1 = 0 ;
29624 int res1 = 0 ;
29625 PyObject *swig_obj[1] ;
29626
29627 if (!args) SWIG_fail;
29628 swig_obj[0] = args;
29629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29630 if (!SWIG_IsOK(res1)) {
29631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29632 }
29633 arg1 = reinterpret_cast< wxWindow * >(argp1);
29634 {
29635 PyThreadState* __tstate = wxPyBeginAllowThreads();
29636 result = (bool)(arg1)->Destroy();
29637 wxPyEndAllowThreads(__tstate);
29638 if (PyErr_Occurred()) SWIG_fail;
29639 }
29640 {
29641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29642 }
29643 return resultobj;
29644 fail:
29645 return NULL;
29646 }
29647
29648
29649 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29650 PyObject *resultobj = 0;
29651 wxWindow *arg1 = (wxWindow *) 0 ;
29652 bool result;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 PyObject *swig_obj[1] ;
29656
29657 if (!args) SWIG_fail;
29658 swig_obj[0] = args;
29659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29662 }
29663 arg1 = reinterpret_cast< wxWindow * >(argp1);
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 result = (bool)(arg1)->DestroyChildren();
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 {
29671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29672 }
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *resultobj = 0;
29681 wxWindow *arg1 = (wxWindow *) 0 ;
29682 bool result;
29683 void *argp1 = 0 ;
29684 int res1 = 0 ;
29685 PyObject *swig_obj[1] ;
29686
29687 if (!args) SWIG_fail;
29688 swig_obj[0] = args;
29689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29690 if (!SWIG_IsOK(res1)) {
29691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29692 }
29693 arg1 = reinterpret_cast< wxWindow * >(argp1);
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj = 0;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 wxString *arg2 = 0 ;
29713 void *argp1 = 0 ;
29714 int res1 = 0 ;
29715 bool temp2 = false ;
29716 PyObject * obj0 = 0 ;
29717 PyObject * obj1 = 0 ;
29718 char * kwnames[] = {
29719 (char *) "self",(char *) "label", NULL
29720 };
29721
29722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29724 if (!SWIG_IsOK(res1)) {
29725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29726 }
29727 arg1 = reinterpret_cast< wxWindow * >(argp1);
29728 {
29729 arg2 = wxString_in_helper(obj1);
29730 if (arg2 == NULL) SWIG_fail;
29731 temp2 = true;
29732 }
29733 {
29734 PyThreadState* __tstate = wxPyBeginAllowThreads();
29735 (arg1)->SetLabel((wxString const &)*arg2);
29736 wxPyEndAllowThreads(__tstate);
29737 if (PyErr_Occurred()) SWIG_fail;
29738 }
29739 resultobj = SWIG_Py_Void();
29740 {
29741 if (temp2)
29742 delete arg2;
29743 }
29744 return resultobj;
29745 fail:
29746 {
29747 if (temp2)
29748 delete arg2;
29749 }
29750 return NULL;
29751 }
29752
29753
29754 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 PyObject *resultobj = 0;
29756 wxWindow *arg1 = (wxWindow *) 0 ;
29757 wxString result;
29758 void *argp1 = 0 ;
29759 int res1 = 0 ;
29760 PyObject *swig_obj[1] ;
29761
29762 if (!args) SWIG_fail;
29763 swig_obj[0] = args;
29764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29765 if (!SWIG_IsOK(res1)) {
29766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29767 }
29768 arg1 = reinterpret_cast< wxWindow * >(argp1);
29769 {
29770 PyThreadState* __tstate = wxPyBeginAllowThreads();
29771 result = ((wxWindow const *)arg1)->GetLabel();
29772 wxPyEndAllowThreads(__tstate);
29773 if (PyErr_Occurred()) SWIG_fail;
29774 }
29775 {
29776 #if wxUSE_UNICODE
29777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29778 #else
29779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29780 #endif
29781 }
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj = 0;
29790 wxWindow *arg1 = (wxWindow *) 0 ;
29791 wxString *arg2 = 0 ;
29792 void *argp1 = 0 ;
29793 int res1 = 0 ;
29794 bool temp2 = false ;
29795 PyObject * obj0 = 0 ;
29796 PyObject * obj1 = 0 ;
29797 char * kwnames[] = {
29798 (char *) "self",(char *) "name", NULL
29799 };
29800
29801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29803 if (!SWIG_IsOK(res1)) {
29804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29805 }
29806 arg1 = reinterpret_cast< wxWindow * >(argp1);
29807 {
29808 arg2 = wxString_in_helper(obj1);
29809 if (arg2 == NULL) SWIG_fail;
29810 temp2 = true;
29811 }
29812 {
29813 PyThreadState* __tstate = wxPyBeginAllowThreads();
29814 (arg1)->SetName((wxString const &)*arg2);
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 resultobj = SWIG_Py_Void();
29819 {
29820 if (temp2)
29821 delete arg2;
29822 }
29823 return resultobj;
29824 fail:
29825 {
29826 if (temp2)
29827 delete arg2;
29828 }
29829 return NULL;
29830 }
29831
29832
29833 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29834 PyObject *resultobj = 0;
29835 wxWindow *arg1 = (wxWindow *) 0 ;
29836 wxString result;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 PyObject *swig_obj[1] ;
29840
29841 if (!args) SWIG_fail;
29842 swig_obj[0] = args;
29843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29846 }
29847 arg1 = reinterpret_cast< wxWindow * >(argp1);
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = ((wxWindow const *)arg1)->GetName();
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 {
29855 #if wxUSE_UNICODE
29856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29857 #else
29858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29859 #endif
29860 }
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj = 0;
29869 wxWindow *arg1 = (wxWindow *) 0 ;
29870 wxWindowVariant arg2 ;
29871 void *argp1 = 0 ;
29872 int res1 = 0 ;
29873 int val2 ;
29874 int ecode2 = 0 ;
29875 PyObject * obj0 = 0 ;
29876 PyObject * obj1 = 0 ;
29877 char * kwnames[] = {
29878 (char *) "self",(char *) "variant", NULL
29879 };
29880
29881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29883 if (!SWIG_IsOK(res1)) {
29884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29885 }
29886 arg1 = reinterpret_cast< wxWindow * >(argp1);
29887 ecode2 = SWIG_AsVal_int(obj1, &val2);
29888 if (!SWIG_IsOK(ecode2)) {
29889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29890 }
29891 arg2 = static_cast< wxWindowVariant >(val2);
29892 {
29893 PyThreadState* __tstate = wxPyBeginAllowThreads();
29894 (arg1)->SetWindowVariant(arg2);
29895 wxPyEndAllowThreads(__tstate);
29896 if (PyErr_Occurred()) SWIG_fail;
29897 }
29898 resultobj = SWIG_Py_Void();
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29906 PyObject *resultobj = 0;
29907 wxWindow *arg1 = (wxWindow *) 0 ;
29908 wxWindowVariant result;
29909 void *argp1 = 0 ;
29910 int res1 = 0 ;
29911 PyObject *swig_obj[1] ;
29912
29913 if (!args) SWIG_fail;
29914 swig_obj[0] = args;
29915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29916 if (!SWIG_IsOK(res1)) {
29917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29918 }
29919 arg1 = reinterpret_cast< wxWindow * >(argp1);
29920 {
29921 PyThreadState* __tstate = wxPyBeginAllowThreads();
29922 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29923 wxPyEndAllowThreads(__tstate);
29924 if (PyErr_Occurred()) SWIG_fail;
29925 }
29926 resultobj = SWIG_From_int(static_cast< int >(result));
29927 return resultobj;
29928 fail:
29929 return NULL;
29930 }
29931
29932
29933 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29934 PyObject *resultobj = 0;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 int arg2 ;
29937 void *argp1 = 0 ;
29938 int res1 = 0 ;
29939 int val2 ;
29940 int ecode2 = 0 ;
29941 PyObject * obj0 = 0 ;
29942 PyObject * obj1 = 0 ;
29943 char * kwnames[] = {
29944 (char *) "self",(char *) "winid", NULL
29945 };
29946
29947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29949 if (!SWIG_IsOK(res1)) {
29950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29951 }
29952 arg1 = reinterpret_cast< wxWindow * >(argp1);
29953 ecode2 = SWIG_AsVal_int(obj1, &val2);
29954 if (!SWIG_IsOK(ecode2)) {
29955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29956 }
29957 arg2 = static_cast< int >(val2);
29958 {
29959 PyThreadState* __tstate = wxPyBeginAllowThreads();
29960 (arg1)->SetId(arg2);
29961 wxPyEndAllowThreads(__tstate);
29962 if (PyErr_Occurred()) SWIG_fail;
29963 }
29964 resultobj = SWIG_Py_Void();
29965 return resultobj;
29966 fail:
29967 return NULL;
29968 }
29969
29970
29971 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29972 PyObject *resultobj = 0;
29973 wxWindow *arg1 = (wxWindow *) 0 ;
29974 int result;
29975 void *argp1 = 0 ;
29976 int res1 = 0 ;
29977 PyObject *swig_obj[1] ;
29978
29979 if (!args) SWIG_fail;
29980 swig_obj[0] = args;
29981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29982 if (!SWIG_IsOK(res1)) {
29983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29984 }
29985 arg1 = reinterpret_cast< wxWindow * >(argp1);
29986 {
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 result = (int)((wxWindow const *)arg1)->GetId();
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 resultobj = SWIG_From_int(static_cast< int >(result));
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30000 PyObject *resultobj = 0;
30001 int result;
30002
30003 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30004 {
30005 PyThreadState* __tstate = wxPyBeginAllowThreads();
30006 result = (int)wxWindow::NewControlId();
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 resultobj = SWIG_From_int(static_cast< int >(result));
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30018 PyObject *resultobj = 0;
30019 int arg1 ;
30020 int result;
30021 int val1 ;
30022 int ecode1 = 0 ;
30023 PyObject * obj0 = 0 ;
30024 char * kwnames[] = {
30025 (char *) "winid", NULL
30026 };
30027
30028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30029 ecode1 = SWIG_AsVal_int(obj0, &val1);
30030 if (!SWIG_IsOK(ecode1)) {
30031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30032 }
30033 arg1 = static_cast< int >(val1);
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (int)wxWindow::NextControlId(arg1);
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 resultobj = SWIG_From_int(static_cast< int >(result));
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30048 PyObject *resultobj = 0;
30049 int arg1 ;
30050 int result;
30051 int val1 ;
30052 int ecode1 = 0 ;
30053 PyObject * obj0 = 0 ;
30054 char * kwnames[] = {
30055 (char *) "winid", NULL
30056 };
30057
30058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30059 ecode1 = SWIG_AsVal_int(obj0, &val1);
30060 if (!SWIG_IsOK(ecode1)) {
30061 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30062 }
30063 arg1 = static_cast< int >(val1);
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (int)wxWindow::PrevControlId(arg1);
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 resultobj = SWIG_From_int(static_cast< int >(result));
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj = 0;
30079 wxWindow *arg1 = (wxWindow *) 0 ;
30080 wxSize *arg2 = 0 ;
30081 void *argp1 = 0 ;
30082 int res1 = 0 ;
30083 wxSize temp2 ;
30084 PyObject * obj0 = 0 ;
30085 PyObject * obj1 = 0 ;
30086 char * kwnames[] = {
30087 (char *) "self",(char *) "size", NULL
30088 };
30089
30090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30092 if (!SWIG_IsOK(res1)) {
30093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30094 }
30095 arg1 = reinterpret_cast< wxWindow * >(argp1);
30096 {
30097 arg2 = &temp2;
30098 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30099 }
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 (arg1)->SetSize((wxSize const &)*arg2);
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 resultobj = SWIG_Py_Void();
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj = 0;
30115 wxWindow *arg1 = (wxWindow *) 0 ;
30116 int arg2 ;
30117 int arg3 ;
30118 int arg4 ;
30119 int arg5 ;
30120 int arg6 = (int) wxSIZE_AUTO ;
30121 void *argp1 = 0 ;
30122 int res1 = 0 ;
30123 int val2 ;
30124 int ecode2 = 0 ;
30125 int val3 ;
30126 int ecode3 = 0 ;
30127 int val4 ;
30128 int ecode4 = 0 ;
30129 int val5 ;
30130 int ecode5 = 0 ;
30131 int val6 ;
30132 int ecode6 = 0 ;
30133 PyObject * obj0 = 0 ;
30134 PyObject * obj1 = 0 ;
30135 PyObject * obj2 = 0 ;
30136 PyObject * obj3 = 0 ;
30137 PyObject * obj4 = 0 ;
30138 PyObject * obj5 = 0 ;
30139 char * kwnames[] = {
30140 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30141 };
30142
30143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30145 if (!SWIG_IsOK(res1)) {
30146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30147 }
30148 arg1 = reinterpret_cast< wxWindow * >(argp1);
30149 ecode2 = SWIG_AsVal_int(obj1, &val2);
30150 if (!SWIG_IsOK(ecode2)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30152 }
30153 arg2 = static_cast< int >(val2);
30154 ecode3 = SWIG_AsVal_int(obj2, &val3);
30155 if (!SWIG_IsOK(ecode3)) {
30156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30157 }
30158 arg3 = static_cast< int >(val3);
30159 ecode4 = SWIG_AsVal_int(obj3, &val4);
30160 if (!SWIG_IsOK(ecode4)) {
30161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30162 }
30163 arg4 = static_cast< int >(val4);
30164 ecode5 = SWIG_AsVal_int(obj4, &val5);
30165 if (!SWIG_IsOK(ecode5)) {
30166 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30167 }
30168 arg5 = static_cast< int >(val5);
30169 if (obj5) {
30170 ecode6 = SWIG_AsVal_int(obj5, &val6);
30171 if (!SWIG_IsOK(ecode6)) {
30172 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30173 }
30174 arg6 = static_cast< int >(val6);
30175 }
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 resultobj = SWIG_Py_Void();
30183 return resultobj;
30184 fail:
30185 return NULL;
30186 }
30187
30188
30189 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30190 PyObject *resultobj = 0;
30191 wxWindow *arg1 = (wxWindow *) 0 ;
30192 wxRect *arg2 = 0 ;
30193 int arg3 = (int) wxSIZE_AUTO ;
30194 void *argp1 = 0 ;
30195 int res1 = 0 ;
30196 wxRect temp2 ;
30197 int val3 ;
30198 int ecode3 = 0 ;
30199 PyObject * obj0 = 0 ;
30200 PyObject * obj1 = 0 ;
30201 PyObject * obj2 = 0 ;
30202 char * kwnames[] = {
30203 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30204 };
30205
30206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30208 if (!SWIG_IsOK(res1)) {
30209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30210 }
30211 arg1 = reinterpret_cast< wxWindow * >(argp1);
30212 {
30213 arg2 = &temp2;
30214 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30215 }
30216 if (obj2) {
30217 ecode3 = SWIG_AsVal_int(obj2, &val3);
30218 if (!SWIG_IsOK(ecode3)) {
30219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30220 }
30221 arg3 = static_cast< int >(val3);
30222 }
30223 {
30224 PyThreadState* __tstate = wxPyBeginAllowThreads();
30225 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 resultobj = SWIG_Py_Void();
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj = 0;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 int arg2 ;
30240 int arg3 ;
30241 void *argp1 = 0 ;
30242 int res1 = 0 ;
30243 int val2 ;
30244 int ecode2 = 0 ;
30245 int val3 ;
30246 int ecode3 = 0 ;
30247 PyObject * obj0 = 0 ;
30248 PyObject * obj1 = 0 ;
30249 PyObject * obj2 = 0 ;
30250 char * kwnames[] = {
30251 (char *) "self",(char *) "width",(char *) "height", NULL
30252 };
30253
30254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30256 if (!SWIG_IsOK(res1)) {
30257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30258 }
30259 arg1 = reinterpret_cast< wxWindow * >(argp1);
30260 ecode2 = SWIG_AsVal_int(obj1, &val2);
30261 if (!SWIG_IsOK(ecode2)) {
30262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30263 }
30264 arg2 = static_cast< int >(val2);
30265 ecode3 = SWIG_AsVal_int(obj2, &val3);
30266 if (!SWIG_IsOK(ecode3)) {
30267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30268 }
30269 arg3 = static_cast< int >(val3);
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 (arg1)->SetSize(arg2,arg3);
30273 wxPyEndAllowThreads(__tstate);
30274 if (PyErr_Occurred()) SWIG_fail;
30275 }
30276 resultobj = SWIG_Py_Void();
30277 return resultobj;
30278 fail:
30279 return NULL;
30280 }
30281
30282
30283 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30284 PyObject *resultobj = 0;
30285 wxWindow *arg1 = (wxWindow *) 0 ;
30286 wxPoint *arg2 = 0 ;
30287 int arg3 = (int) wxSIZE_USE_EXISTING ;
30288 void *argp1 = 0 ;
30289 int res1 = 0 ;
30290 wxPoint temp2 ;
30291 int val3 ;
30292 int ecode3 = 0 ;
30293 PyObject * obj0 = 0 ;
30294 PyObject * obj1 = 0 ;
30295 PyObject * obj2 = 0 ;
30296 char * kwnames[] = {
30297 (char *) "self",(char *) "pt",(char *) "flags", NULL
30298 };
30299
30300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30302 if (!SWIG_IsOK(res1)) {
30303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30304 }
30305 arg1 = reinterpret_cast< wxWindow * >(argp1);
30306 {
30307 arg2 = &temp2;
30308 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30309 }
30310 if (obj2) {
30311 ecode3 = SWIG_AsVal_int(obj2, &val3);
30312 if (!SWIG_IsOK(ecode3)) {
30313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30314 }
30315 arg3 = static_cast< int >(val3);
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 (arg1)->Move((wxPoint const &)*arg2,arg3);
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 resultobj = SWIG_Py_Void();
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj = 0;
30332 wxWindow *arg1 = (wxWindow *) 0 ;
30333 int arg2 ;
30334 int arg3 ;
30335 int arg4 = (int) wxSIZE_USE_EXISTING ;
30336 void *argp1 = 0 ;
30337 int res1 = 0 ;
30338 int val2 ;
30339 int ecode2 = 0 ;
30340 int val3 ;
30341 int ecode3 = 0 ;
30342 int val4 ;
30343 int ecode4 = 0 ;
30344 PyObject * obj0 = 0 ;
30345 PyObject * obj1 = 0 ;
30346 PyObject * obj2 = 0 ;
30347 PyObject * obj3 = 0 ;
30348 char * kwnames[] = {
30349 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30350 };
30351
30352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30354 if (!SWIG_IsOK(res1)) {
30355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30356 }
30357 arg1 = reinterpret_cast< wxWindow * >(argp1);
30358 ecode2 = SWIG_AsVal_int(obj1, &val2);
30359 if (!SWIG_IsOK(ecode2)) {
30360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30361 }
30362 arg2 = static_cast< int >(val2);
30363 ecode3 = SWIG_AsVal_int(obj2, &val3);
30364 if (!SWIG_IsOK(ecode3)) {
30365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30366 }
30367 arg3 = static_cast< int >(val3);
30368 if (obj3) {
30369 ecode4 = SWIG_AsVal_int(obj3, &val4);
30370 if (!SWIG_IsOK(ecode4)) {
30371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30372 }
30373 arg4 = static_cast< int >(val4);
30374 }
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 (arg1)->Move(arg2,arg3,arg4);
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 resultobj = SWIG_Py_Void();
30382 return resultobj;
30383 fail:
30384 return NULL;
30385 }
30386
30387
30388 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30389 PyObject *resultobj = 0;
30390 wxWindow *arg1 = (wxWindow *) 0 ;
30391 wxSize const &arg2_defvalue = wxDefaultSize ;
30392 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 wxSize temp2 ;
30396 PyObject * obj0 = 0 ;
30397 PyObject * obj1 = 0 ;
30398 char * kwnames[] = {
30399 (char *) "self",(char *) "size", NULL
30400 };
30401
30402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30404 if (!SWIG_IsOK(res1)) {
30405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30406 }
30407 arg1 = reinterpret_cast< wxWindow * >(argp1);
30408 if (obj1) {
30409 {
30410 arg2 = &temp2;
30411 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30412 }
30413 }
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 resultobj = SWIG_Py_Void();
30421 return resultobj;
30422 fail:
30423 return NULL;
30424 }
30425
30426
30427 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30428 PyObject *resultobj = 0;
30429 wxWindow *arg1 = (wxWindow *) 0 ;
30430 void *argp1 = 0 ;
30431 int res1 = 0 ;
30432 PyObject *swig_obj[1] ;
30433
30434 if (!args) SWIG_fail;
30435 swig_obj[0] = args;
30436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30437 if (!SWIG_IsOK(res1)) {
30438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30439 }
30440 arg1 = reinterpret_cast< wxWindow * >(argp1);
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 (arg1)->Raise();
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 resultobj = SWIG_Py_Void();
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxWindow *arg1 = (wxWindow *) 0 ;
30457 void *argp1 = 0 ;
30458 int res1 = 0 ;
30459 PyObject *swig_obj[1] ;
30460
30461 if (!args) SWIG_fail;
30462 swig_obj[0] = args;
30463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30464 if (!SWIG_IsOK(res1)) {
30465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30466 }
30467 arg1 = reinterpret_cast< wxWindow * >(argp1);
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 (arg1)->Lower();
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 resultobj = SWIG_Py_Void();
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30482 PyObject *resultobj = 0;
30483 wxWindow *arg1 = (wxWindow *) 0 ;
30484 wxSize *arg2 = 0 ;
30485 void *argp1 = 0 ;
30486 int res1 = 0 ;
30487 wxSize temp2 ;
30488 PyObject * obj0 = 0 ;
30489 PyObject * obj1 = 0 ;
30490 char * kwnames[] = {
30491 (char *) "self",(char *) "size", NULL
30492 };
30493
30494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30496 if (!SWIG_IsOK(res1)) {
30497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30498 }
30499 arg1 = reinterpret_cast< wxWindow * >(argp1);
30500 {
30501 arg2 = &temp2;
30502 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 (arg1)->SetClientSize((wxSize const &)*arg2);
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 resultobj = SWIG_Py_Void();
30511 return resultobj;
30512 fail:
30513 return NULL;
30514 }
30515
30516
30517 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30518 PyObject *resultobj = 0;
30519 wxWindow *arg1 = (wxWindow *) 0 ;
30520 int arg2 ;
30521 int arg3 ;
30522 void *argp1 = 0 ;
30523 int res1 = 0 ;
30524 int val2 ;
30525 int ecode2 = 0 ;
30526 int val3 ;
30527 int ecode3 = 0 ;
30528 PyObject * obj0 = 0 ;
30529 PyObject * obj1 = 0 ;
30530 PyObject * obj2 = 0 ;
30531 char * kwnames[] = {
30532 (char *) "self",(char *) "width",(char *) "height", NULL
30533 };
30534
30535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30537 if (!SWIG_IsOK(res1)) {
30538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30539 }
30540 arg1 = reinterpret_cast< wxWindow * >(argp1);
30541 ecode2 = SWIG_AsVal_int(obj1, &val2);
30542 if (!SWIG_IsOK(ecode2)) {
30543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30544 }
30545 arg2 = static_cast< int >(val2);
30546 ecode3 = SWIG_AsVal_int(obj2, &val3);
30547 if (!SWIG_IsOK(ecode3)) {
30548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30549 }
30550 arg3 = static_cast< int >(val3);
30551 {
30552 PyThreadState* __tstate = wxPyBeginAllowThreads();
30553 (arg1)->SetClientSize(arg2,arg3);
30554 wxPyEndAllowThreads(__tstate);
30555 if (PyErr_Occurred()) SWIG_fail;
30556 }
30557 resultobj = SWIG_Py_Void();
30558 return resultobj;
30559 fail:
30560 return NULL;
30561 }
30562
30563
30564 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30565 PyObject *resultobj = 0;
30566 wxWindow *arg1 = (wxWindow *) 0 ;
30567 wxRect *arg2 = 0 ;
30568 void *argp1 = 0 ;
30569 int res1 = 0 ;
30570 wxRect temp2 ;
30571 PyObject * obj0 = 0 ;
30572 PyObject * obj1 = 0 ;
30573 char * kwnames[] = {
30574 (char *) "self",(char *) "rect", NULL
30575 };
30576
30577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30581 }
30582 arg1 = reinterpret_cast< wxWindow * >(argp1);
30583 {
30584 arg2 = &temp2;
30585 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30586 }
30587 {
30588 PyThreadState* __tstate = wxPyBeginAllowThreads();
30589 (arg1)->SetClientSize((wxRect const &)*arg2);
30590 wxPyEndAllowThreads(__tstate);
30591 if (PyErr_Occurred()) SWIG_fail;
30592 }
30593 resultobj = SWIG_Py_Void();
30594 return resultobj;
30595 fail:
30596 return NULL;
30597 }
30598
30599
30600 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30601 PyObject *resultobj = 0;
30602 wxWindow *arg1 = (wxWindow *) 0 ;
30603 wxPoint result;
30604 void *argp1 = 0 ;
30605 int res1 = 0 ;
30606 PyObject *swig_obj[1] ;
30607
30608 if (!args) SWIG_fail;
30609 swig_obj[0] = args;
30610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30611 if (!SWIG_IsOK(res1)) {
30612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30613 }
30614 arg1 = reinterpret_cast< wxWindow * >(argp1);
30615 {
30616 PyThreadState* __tstate = wxPyBeginAllowThreads();
30617 result = ((wxWindow const *)arg1)->GetPosition();
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30629 PyObject *resultobj = 0;
30630 wxWindow *arg1 = (wxWindow *) 0 ;
30631 int *arg2 = (int *) 0 ;
30632 int *arg3 = (int *) 0 ;
30633 void *argp1 = 0 ;
30634 int res1 = 0 ;
30635 int temp2 ;
30636 int res2 = SWIG_TMPOBJ ;
30637 int temp3 ;
30638 int res3 = SWIG_TMPOBJ ;
30639 PyObject *swig_obj[1] ;
30640
30641 arg2 = &temp2;
30642 arg3 = &temp3;
30643 if (!args) SWIG_fail;
30644 swig_obj[0] = args;
30645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30646 if (!SWIG_IsOK(res1)) {
30647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30648 }
30649 arg1 = reinterpret_cast< wxWindow * >(argp1);
30650 {
30651 PyThreadState* __tstate = wxPyBeginAllowThreads();
30652 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30653 wxPyEndAllowThreads(__tstate);
30654 if (PyErr_Occurred()) SWIG_fail;
30655 }
30656 resultobj = SWIG_Py_Void();
30657 if (SWIG_IsTmpObj(res2)) {
30658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30659 } else {
30660 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30662 }
30663 if (SWIG_IsTmpObj(res3)) {
30664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30665 } else {
30666 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30667 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30668 }
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30676 PyObject *resultobj = 0;
30677 wxWindow *arg1 = (wxWindow *) 0 ;
30678 wxPoint result;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 PyObject *swig_obj[1] ;
30682
30683 if (!args) SWIG_fail;
30684 swig_obj[0] = args;
30685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30686 if (!SWIG_IsOK(res1)) {
30687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30688 }
30689 arg1 = reinterpret_cast< wxWindow * >(argp1);
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 result = ((wxWindow const *)arg1)->GetScreenPosition();
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30697 return resultobj;
30698 fail:
30699 return NULL;
30700 }
30701
30702
30703 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30704 PyObject *resultobj = 0;
30705 wxWindow *arg1 = (wxWindow *) 0 ;
30706 int *arg2 = (int *) 0 ;
30707 int *arg3 = (int *) 0 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 int temp2 ;
30711 int res2 = SWIG_TMPOBJ ;
30712 int temp3 ;
30713 int res3 = SWIG_TMPOBJ ;
30714 PyObject *swig_obj[1] ;
30715
30716 arg2 = &temp2;
30717 arg3 = &temp3;
30718 if (!args) SWIG_fail;
30719 swig_obj[0] = args;
30720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30721 if (!SWIG_IsOK(res1)) {
30722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30723 }
30724 arg1 = reinterpret_cast< wxWindow * >(argp1);
30725 {
30726 PyThreadState* __tstate = wxPyBeginAllowThreads();
30727 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 resultobj = SWIG_Py_Void();
30732 if (SWIG_IsTmpObj(res2)) {
30733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30734 } else {
30735 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30737 }
30738 if (SWIG_IsTmpObj(res3)) {
30739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30740 } else {
30741 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30743 }
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30751 PyObject *resultobj = 0;
30752 wxWindow *arg1 = (wxWindow *) 0 ;
30753 wxRect result;
30754 void *argp1 = 0 ;
30755 int res1 = 0 ;
30756 PyObject *swig_obj[1] ;
30757
30758 if (!args) SWIG_fail;
30759 swig_obj[0] = args;
30760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30761 if (!SWIG_IsOK(res1)) {
30762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30763 }
30764 arg1 = reinterpret_cast< wxWindow * >(argp1);
30765 {
30766 PyThreadState* __tstate = wxPyBeginAllowThreads();
30767 result = ((wxWindow const *)arg1)->GetScreenRect();
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30779 PyObject *resultobj = 0;
30780 wxWindow *arg1 = (wxWindow *) 0 ;
30781 wxSize result;
30782 void *argp1 = 0 ;
30783 int res1 = 0 ;
30784 PyObject *swig_obj[1] ;
30785
30786 if (!args) SWIG_fail;
30787 swig_obj[0] = args;
30788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30789 if (!SWIG_IsOK(res1)) {
30790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30791 }
30792 arg1 = reinterpret_cast< wxWindow * >(argp1);
30793 {
30794 PyThreadState* __tstate = wxPyBeginAllowThreads();
30795 result = ((wxWindow const *)arg1)->GetSize();
30796 wxPyEndAllowThreads(__tstate);
30797 if (PyErr_Occurred()) SWIG_fail;
30798 }
30799 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30807 PyObject *resultobj = 0;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 int *arg2 = (int *) 0 ;
30810 int *arg3 = (int *) 0 ;
30811 void *argp1 = 0 ;
30812 int res1 = 0 ;
30813 int temp2 ;
30814 int res2 = SWIG_TMPOBJ ;
30815 int temp3 ;
30816 int res3 = SWIG_TMPOBJ ;
30817 PyObject *swig_obj[1] ;
30818
30819 arg2 = &temp2;
30820 arg3 = &temp3;
30821 if (!args) SWIG_fail;
30822 swig_obj[0] = args;
30823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30826 }
30827 arg1 = reinterpret_cast< wxWindow * >(argp1);
30828 {
30829 PyThreadState* __tstate = wxPyBeginAllowThreads();
30830 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30831 wxPyEndAllowThreads(__tstate);
30832 if (PyErr_Occurred()) SWIG_fail;
30833 }
30834 resultobj = SWIG_Py_Void();
30835 if (SWIG_IsTmpObj(res2)) {
30836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30837 } else {
30838 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30840 }
30841 if (SWIG_IsTmpObj(res3)) {
30842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30843 } else {
30844 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30845 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30846 }
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30854 PyObject *resultobj = 0;
30855 wxWindow *arg1 = (wxWindow *) 0 ;
30856 wxRect result;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 PyObject *swig_obj[1] ;
30860
30861 if (!args) SWIG_fail;
30862 swig_obj[0] = args;
30863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30864 if (!SWIG_IsOK(res1)) {
30865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30866 }
30867 arg1 = reinterpret_cast< wxWindow * >(argp1);
30868 {
30869 PyThreadState* __tstate = wxPyBeginAllowThreads();
30870 result = ((wxWindow const *)arg1)->GetRect();
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30875 return resultobj;
30876 fail:
30877 return NULL;
30878 }
30879
30880
30881 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30882 PyObject *resultobj = 0;
30883 wxWindow *arg1 = (wxWindow *) 0 ;
30884 wxSize result;
30885 void *argp1 = 0 ;
30886 int res1 = 0 ;
30887 PyObject *swig_obj[1] ;
30888
30889 if (!args) SWIG_fail;
30890 swig_obj[0] = args;
30891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30892 if (!SWIG_IsOK(res1)) {
30893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30894 }
30895 arg1 = reinterpret_cast< wxWindow * >(argp1);
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = ((wxWindow const *)arg1)->GetClientSize();
30899 wxPyEndAllowThreads(__tstate);
30900 if (PyErr_Occurred()) SWIG_fail;
30901 }
30902 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30910 PyObject *resultobj = 0;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 int *arg2 = (int *) 0 ;
30913 int *arg3 = (int *) 0 ;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 int temp2 ;
30917 int res2 = SWIG_TMPOBJ ;
30918 int temp3 ;
30919 int res3 = SWIG_TMPOBJ ;
30920 PyObject *swig_obj[1] ;
30921
30922 arg2 = &temp2;
30923 arg3 = &temp3;
30924 if (!args) SWIG_fail;
30925 swig_obj[0] = args;
30926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30927 if (!SWIG_IsOK(res1)) {
30928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30929 }
30930 arg1 = reinterpret_cast< wxWindow * >(argp1);
30931 {
30932 PyThreadState* __tstate = wxPyBeginAllowThreads();
30933 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30934 wxPyEndAllowThreads(__tstate);
30935 if (PyErr_Occurred()) SWIG_fail;
30936 }
30937 resultobj = SWIG_Py_Void();
30938 if (SWIG_IsTmpObj(res2)) {
30939 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30940 } else {
30941 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30943 }
30944 if (SWIG_IsTmpObj(res3)) {
30945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30946 } else {
30947 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30949 }
30950 return resultobj;
30951 fail:
30952 return NULL;
30953 }
30954
30955
30956 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30957 PyObject *resultobj = 0;
30958 wxWindow *arg1 = (wxWindow *) 0 ;
30959 wxPoint result;
30960 void *argp1 = 0 ;
30961 int res1 = 0 ;
30962 PyObject *swig_obj[1] ;
30963
30964 if (!args) SWIG_fail;
30965 swig_obj[0] = args;
30966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30967 if (!SWIG_IsOK(res1)) {
30968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30969 }
30970 arg1 = reinterpret_cast< wxWindow * >(argp1);
30971 {
30972 PyThreadState* __tstate = wxPyBeginAllowThreads();
30973 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30978 return resultobj;
30979 fail:
30980 return NULL;
30981 }
30982
30983
30984 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30985 PyObject *resultobj = 0;
30986 wxWindow *arg1 = (wxWindow *) 0 ;
30987 wxRect result;
30988 void *argp1 = 0 ;
30989 int res1 = 0 ;
30990 PyObject *swig_obj[1] ;
30991
30992 if (!args) SWIG_fail;
30993 swig_obj[0] = args;
30994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30995 if (!SWIG_IsOK(res1)) {
30996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30997 }
30998 arg1 = reinterpret_cast< wxWindow * >(argp1);
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 result = ((wxWindow const *)arg1)->GetClientRect();
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 wxSize result;
31016 void *argp1 = 0 ;
31017 int res1 = 0 ;
31018 PyObject *swig_obj[1] ;
31019
31020 if (!args) SWIG_fail;
31021 swig_obj[0] = args;
31022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31023 if (!SWIG_IsOK(res1)) {
31024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31025 }
31026 arg1 = reinterpret_cast< wxWindow * >(argp1);
31027 {
31028 PyThreadState* __tstate = wxPyBeginAllowThreads();
31029 result = ((wxWindow const *)arg1)->GetBestSize();
31030 wxPyEndAllowThreads(__tstate);
31031 if (PyErr_Occurred()) SWIG_fail;
31032 }
31033 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31034 return resultobj;
31035 fail:
31036 return NULL;
31037 }
31038
31039
31040 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31041 PyObject *resultobj = 0;
31042 wxWindow *arg1 = (wxWindow *) 0 ;
31043 int *arg2 = (int *) 0 ;
31044 int *arg3 = (int *) 0 ;
31045 void *argp1 = 0 ;
31046 int res1 = 0 ;
31047 int temp2 ;
31048 int res2 = SWIG_TMPOBJ ;
31049 int temp3 ;
31050 int res3 = SWIG_TMPOBJ ;
31051 PyObject *swig_obj[1] ;
31052
31053 arg2 = &temp2;
31054 arg3 = &temp3;
31055 if (!args) SWIG_fail;
31056 swig_obj[0] = args;
31057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31058 if (!SWIG_IsOK(res1)) {
31059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31060 }
31061 arg1 = reinterpret_cast< wxWindow * >(argp1);
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31065 wxPyEndAllowThreads(__tstate);
31066 if (PyErr_Occurred()) SWIG_fail;
31067 }
31068 resultobj = SWIG_Py_Void();
31069 if (SWIG_IsTmpObj(res2)) {
31070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31071 } else {
31072 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31073 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31074 }
31075 if (SWIG_IsTmpObj(res3)) {
31076 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31077 } else {
31078 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31079 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31080 }
31081 return resultobj;
31082 fail:
31083 return NULL;
31084 }
31085
31086
31087 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31088 PyObject *resultobj = 0;
31089 wxWindow *arg1 = (wxWindow *) 0 ;
31090 void *argp1 = 0 ;
31091 int res1 = 0 ;
31092 PyObject *swig_obj[1] ;
31093
31094 if (!args) SWIG_fail;
31095 swig_obj[0] = args;
31096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31097 if (!SWIG_IsOK(res1)) {
31098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31099 }
31100 arg1 = reinterpret_cast< wxWindow * >(argp1);
31101 {
31102 PyThreadState* __tstate = wxPyBeginAllowThreads();
31103 (arg1)->InvalidateBestSize();
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 resultobj = SWIG_Py_Void();
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj = 0;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 wxSize *arg2 = 0 ;
31118 void *argp1 = 0 ;
31119 int res1 = 0 ;
31120 wxSize temp2 ;
31121 PyObject * obj0 = 0 ;
31122 PyObject * obj1 = 0 ;
31123 char * kwnames[] = {
31124 (char *) "self",(char *) "size", NULL
31125 };
31126
31127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31129 if (!SWIG_IsOK(res1)) {
31130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31131 }
31132 arg1 = reinterpret_cast< wxWindow * >(argp1);
31133 {
31134 arg2 = &temp2;
31135 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31136 }
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 resultobj = SWIG_Py_Void();
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31151 PyObject *resultobj = 0;
31152 wxWindow *arg1 = (wxWindow *) 0 ;
31153 wxSize result;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 PyObject *swig_obj[1] ;
31157
31158 if (!args) SWIG_fail;
31159 swig_obj[0] = args;
31160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31161 if (!SWIG_IsOK(res1)) {
31162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31163 }
31164 arg1 = reinterpret_cast< wxWindow * >(argp1);
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 wxWindow *arg1 = (wxWindow *) 0 ;
31181 wxSize result;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject *swig_obj[1] ;
31185
31186 if (!args) SWIG_fail;
31187 swig_obj[0] = args;
31188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31189 if (!SWIG_IsOK(res1)) {
31190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31191 }
31192 arg1 = reinterpret_cast< wxWindow * >(argp1);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 int arg2 = (int) wxBOTH ;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 int val2 ;
31213 int ecode2 = 0 ;
31214 PyObject * obj0 = 0 ;
31215 PyObject * obj1 = 0 ;
31216 char * kwnames[] = {
31217 (char *) "self",(char *) "direction", NULL
31218 };
31219
31220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31222 if (!SWIG_IsOK(res1)) {
31223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31224 }
31225 arg1 = reinterpret_cast< wxWindow * >(argp1);
31226 if (obj1) {
31227 ecode2 = SWIG_AsVal_int(obj1, &val2);
31228 if (!SWIG_IsOK(ecode2)) {
31229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31230 }
31231 arg2 = static_cast< int >(val2);
31232 }
31233 {
31234 PyThreadState* __tstate = wxPyBeginAllowThreads();
31235 (arg1)->Center(arg2);
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 resultobj = SWIG_Py_Void();
31240 return resultobj;
31241 fail:
31242 return NULL;
31243 }
31244
31245
31246 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31247 PyObject *resultobj = 0;
31248 wxWindow *arg1 = (wxWindow *) 0 ;
31249 int arg2 = (int) wxBOTH ;
31250 void *argp1 = 0 ;
31251 int res1 = 0 ;
31252 int val2 ;
31253 int ecode2 = 0 ;
31254 PyObject * obj0 = 0 ;
31255 PyObject * obj1 = 0 ;
31256 char * kwnames[] = {
31257 (char *) "self",(char *) "dir", NULL
31258 };
31259
31260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31262 if (!SWIG_IsOK(res1)) {
31263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31264 }
31265 arg1 = reinterpret_cast< wxWindow * >(argp1);
31266 if (obj1) {
31267 ecode2 = SWIG_AsVal_int(obj1, &val2);
31268 if (!SWIG_IsOK(ecode2)) {
31269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31270 }
31271 arg2 = static_cast< int >(val2);
31272 }
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 (arg1)->CenterOnParent(arg2);
31276 wxPyEndAllowThreads(__tstate);
31277 if (PyErr_Occurred()) SWIG_fail;
31278 }
31279 resultobj = SWIG_Py_Void();
31280 return resultobj;
31281 fail:
31282 return NULL;
31283 }
31284
31285
31286 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31287 PyObject *resultobj = 0;
31288 wxWindow *arg1 = (wxWindow *) 0 ;
31289 void *argp1 = 0 ;
31290 int res1 = 0 ;
31291 PyObject *swig_obj[1] ;
31292
31293 if (!args) SWIG_fail;
31294 swig_obj[0] = args;
31295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31296 if (!SWIG_IsOK(res1)) {
31297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31298 }
31299 arg1 = reinterpret_cast< wxWindow * >(argp1);
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 (arg1)->Fit();
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 resultobj = SWIG_Py_Void();
31307 return resultobj;
31308 fail:
31309 return NULL;
31310 }
31311
31312
31313 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31314 PyObject *resultobj = 0;
31315 wxWindow *arg1 = (wxWindow *) 0 ;
31316 void *argp1 = 0 ;
31317 int res1 = 0 ;
31318 PyObject *swig_obj[1] ;
31319
31320 if (!args) SWIG_fail;
31321 swig_obj[0] = args;
31322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31323 if (!SWIG_IsOK(res1)) {
31324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31325 }
31326 arg1 = reinterpret_cast< wxWindow * >(argp1);
31327 {
31328 PyThreadState* __tstate = wxPyBeginAllowThreads();
31329 (arg1)->FitInside();
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 resultobj = SWIG_Py_Void();
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31341 PyObject *resultobj = 0;
31342 wxWindow *arg1 = (wxWindow *) 0 ;
31343 int arg2 ;
31344 int arg3 ;
31345 int arg4 = (int) -1 ;
31346 int arg5 = (int) -1 ;
31347 int arg6 = (int) -1 ;
31348 int arg7 = (int) -1 ;
31349 void *argp1 = 0 ;
31350 int res1 = 0 ;
31351 int val2 ;
31352 int ecode2 = 0 ;
31353 int val3 ;
31354 int ecode3 = 0 ;
31355 int val4 ;
31356 int ecode4 = 0 ;
31357 int val5 ;
31358 int ecode5 = 0 ;
31359 int val6 ;
31360 int ecode6 = 0 ;
31361 int val7 ;
31362 int ecode7 = 0 ;
31363 PyObject * obj0 = 0 ;
31364 PyObject * obj1 = 0 ;
31365 PyObject * obj2 = 0 ;
31366 PyObject * obj3 = 0 ;
31367 PyObject * obj4 = 0 ;
31368 PyObject * obj5 = 0 ;
31369 PyObject * obj6 = 0 ;
31370 char * kwnames[] = {
31371 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31372 };
31373
31374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31376 if (!SWIG_IsOK(res1)) {
31377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31378 }
31379 arg1 = reinterpret_cast< wxWindow * >(argp1);
31380 ecode2 = SWIG_AsVal_int(obj1, &val2);
31381 if (!SWIG_IsOK(ecode2)) {
31382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31383 }
31384 arg2 = static_cast< int >(val2);
31385 ecode3 = SWIG_AsVal_int(obj2, &val3);
31386 if (!SWIG_IsOK(ecode3)) {
31387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31388 }
31389 arg3 = static_cast< int >(val3);
31390 if (obj3) {
31391 ecode4 = SWIG_AsVal_int(obj3, &val4);
31392 if (!SWIG_IsOK(ecode4)) {
31393 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31394 }
31395 arg4 = static_cast< int >(val4);
31396 }
31397 if (obj4) {
31398 ecode5 = SWIG_AsVal_int(obj4, &val5);
31399 if (!SWIG_IsOK(ecode5)) {
31400 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31401 }
31402 arg5 = static_cast< int >(val5);
31403 }
31404 if (obj5) {
31405 ecode6 = SWIG_AsVal_int(obj5, &val6);
31406 if (!SWIG_IsOK(ecode6)) {
31407 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31408 }
31409 arg6 = static_cast< int >(val6);
31410 }
31411 if (obj6) {
31412 ecode7 = SWIG_AsVal_int(obj6, &val7);
31413 if (!SWIG_IsOK(ecode7)) {
31414 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31415 }
31416 arg7 = static_cast< int >(val7);
31417 }
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 resultobj = SWIG_Py_Void();
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj = 0;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 wxSize *arg2 = 0 ;
31435 wxSize const &arg3_defvalue = wxDefaultSize ;
31436 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31437 wxSize const &arg4_defvalue = wxDefaultSize ;
31438 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31439 void *argp1 = 0 ;
31440 int res1 = 0 ;
31441 wxSize temp2 ;
31442 wxSize temp3 ;
31443 wxSize temp4 ;
31444 PyObject * obj0 = 0 ;
31445 PyObject * obj1 = 0 ;
31446 PyObject * obj2 = 0 ;
31447 PyObject * obj3 = 0 ;
31448 char * kwnames[] = {
31449 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31450 };
31451
31452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31454 if (!SWIG_IsOK(res1)) {
31455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31456 }
31457 arg1 = reinterpret_cast< wxWindow * >(argp1);
31458 {
31459 arg2 = &temp2;
31460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31461 }
31462 if (obj2) {
31463 {
31464 arg3 = &temp3;
31465 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31466 }
31467 }
31468 if (obj3) {
31469 {
31470 arg4 = &temp4;
31471 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31472 }
31473 }
31474 {
31475 PyThreadState* __tstate = wxPyBeginAllowThreads();
31476 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 resultobj = SWIG_Py_Void();
31481 return resultobj;
31482 fail:
31483 return NULL;
31484 }
31485
31486
31487 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31488 PyObject *resultobj = 0;
31489 wxWindow *arg1 = (wxWindow *) 0 ;
31490 int arg2 ;
31491 int arg3 ;
31492 int arg4 = (int) -1 ;
31493 int arg5 = (int) -1 ;
31494 void *argp1 = 0 ;
31495 int res1 = 0 ;
31496 int val2 ;
31497 int ecode2 = 0 ;
31498 int val3 ;
31499 int ecode3 = 0 ;
31500 int val4 ;
31501 int ecode4 = 0 ;
31502 int val5 ;
31503 int ecode5 = 0 ;
31504 PyObject * obj0 = 0 ;
31505 PyObject * obj1 = 0 ;
31506 PyObject * obj2 = 0 ;
31507 PyObject * obj3 = 0 ;
31508 PyObject * obj4 = 0 ;
31509 char * kwnames[] = {
31510 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31511 };
31512
31513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31515 if (!SWIG_IsOK(res1)) {
31516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31517 }
31518 arg1 = reinterpret_cast< wxWindow * >(argp1);
31519 ecode2 = SWIG_AsVal_int(obj1, &val2);
31520 if (!SWIG_IsOK(ecode2)) {
31521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31522 }
31523 arg2 = static_cast< int >(val2);
31524 ecode3 = SWIG_AsVal_int(obj2, &val3);
31525 if (!SWIG_IsOK(ecode3)) {
31526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31527 }
31528 arg3 = static_cast< int >(val3);
31529 if (obj3) {
31530 ecode4 = SWIG_AsVal_int(obj3, &val4);
31531 if (!SWIG_IsOK(ecode4)) {
31532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31533 }
31534 arg4 = static_cast< int >(val4);
31535 }
31536 if (obj4) {
31537 ecode5 = SWIG_AsVal_int(obj4, &val5);
31538 if (!SWIG_IsOK(ecode5)) {
31539 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31540 }
31541 arg5 = static_cast< int >(val5);
31542 }
31543 {
31544 PyThreadState* __tstate = wxPyBeginAllowThreads();
31545 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31546 wxPyEndAllowThreads(__tstate);
31547 if (PyErr_Occurred()) SWIG_fail;
31548 }
31549 resultobj = SWIG_Py_Void();
31550 return resultobj;
31551 fail:
31552 return NULL;
31553 }
31554
31555
31556 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31557 PyObject *resultobj = 0;
31558 wxWindow *arg1 = (wxWindow *) 0 ;
31559 wxSize *arg2 = 0 ;
31560 wxSize const &arg3_defvalue = wxDefaultSize ;
31561 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31562 void *argp1 = 0 ;
31563 int res1 = 0 ;
31564 wxSize temp2 ;
31565 wxSize temp3 ;
31566 PyObject * obj0 = 0 ;
31567 PyObject * obj1 = 0 ;
31568 PyObject * obj2 = 0 ;
31569 char * kwnames[] = {
31570 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31571 };
31572
31573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31575 if (!SWIG_IsOK(res1)) {
31576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31577 }
31578 arg1 = reinterpret_cast< wxWindow * >(argp1);
31579 {
31580 arg2 = &temp2;
31581 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31582 }
31583 if (obj2) {
31584 {
31585 arg3 = &temp3;
31586 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31587 }
31588 }
31589 {
31590 PyThreadState* __tstate = wxPyBeginAllowThreads();
31591 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31592 wxPyEndAllowThreads(__tstate);
31593 if (PyErr_Occurred()) SWIG_fail;
31594 }
31595 resultobj = SWIG_Py_Void();
31596 return resultobj;
31597 fail:
31598 return NULL;
31599 }
31600
31601
31602 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31603 PyObject *resultobj = 0;
31604 wxWindow *arg1 = (wxWindow *) 0 ;
31605 wxSize result;
31606 void *argp1 = 0 ;
31607 int res1 = 0 ;
31608 PyObject *swig_obj[1] ;
31609
31610 if (!args) SWIG_fail;
31611 swig_obj[0] = args;
31612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31615 }
31616 arg1 = reinterpret_cast< wxWindow * >(argp1);
31617 {
31618 PyThreadState* __tstate = wxPyBeginAllowThreads();
31619 result = ((wxWindow const *)arg1)->GetMaxSize();
31620 wxPyEndAllowThreads(__tstate);
31621 if (PyErr_Occurred()) SWIG_fail;
31622 }
31623 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31624 return resultobj;
31625 fail:
31626 return NULL;
31627 }
31628
31629
31630 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31631 PyObject *resultobj = 0;
31632 wxWindow *arg1 = (wxWindow *) 0 ;
31633 wxSize result;
31634 void *argp1 = 0 ;
31635 int res1 = 0 ;
31636 PyObject *swig_obj[1] ;
31637
31638 if (!args) SWIG_fail;
31639 swig_obj[0] = args;
31640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31641 if (!SWIG_IsOK(res1)) {
31642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31643 }
31644 arg1 = reinterpret_cast< wxWindow * >(argp1);
31645 {
31646 PyThreadState* __tstate = wxPyBeginAllowThreads();
31647 result = ((wxWindow const *)arg1)->GetMinSize();
31648 wxPyEndAllowThreads(__tstate);
31649 if (PyErr_Occurred()) SWIG_fail;
31650 }
31651 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31652 return resultobj;
31653 fail:
31654 return NULL;
31655 }
31656
31657
31658 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31659 PyObject *resultobj = 0;
31660 wxWindow *arg1 = (wxWindow *) 0 ;
31661 wxSize *arg2 = 0 ;
31662 void *argp1 = 0 ;
31663 int res1 = 0 ;
31664 wxSize temp2 ;
31665 PyObject * obj0 = 0 ;
31666 PyObject * obj1 = 0 ;
31667 char * kwnames[] = {
31668 (char *) "self",(char *) "minSize", NULL
31669 };
31670
31671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31673 if (!SWIG_IsOK(res1)) {
31674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31675 }
31676 arg1 = reinterpret_cast< wxWindow * >(argp1);
31677 {
31678 arg2 = &temp2;
31679 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31680 }
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 (arg1)->SetMinSize((wxSize const &)*arg2);
31684 wxPyEndAllowThreads(__tstate);
31685 if (PyErr_Occurred()) SWIG_fail;
31686 }
31687 resultobj = SWIG_Py_Void();
31688 return resultobj;
31689 fail:
31690 return NULL;
31691 }
31692
31693
31694 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31695 PyObject *resultobj = 0;
31696 wxWindow *arg1 = (wxWindow *) 0 ;
31697 wxSize *arg2 = 0 ;
31698 void *argp1 = 0 ;
31699 int res1 = 0 ;
31700 wxSize temp2 ;
31701 PyObject * obj0 = 0 ;
31702 PyObject * obj1 = 0 ;
31703 char * kwnames[] = {
31704 (char *) "self",(char *) "maxSize", NULL
31705 };
31706
31707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31709 if (!SWIG_IsOK(res1)) {
31710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31711 }
31712 arg1 = reinterpret_cast< wxWindow * >(argp1);
31713 {
31714 arg2 = &temp2;
31715 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31716 }
31717 {
31718 PyThreadState* __tstate = wxPyBeginAllowThreads();
31719 (arg1)->SetMaxSize((wxSize const &)*arg2);
31720 wxPyEndAllowThreads(__tstate);
31721 if (PyErr_Occurred()) SWIG_fail;
31722 }
31723 resultobj = SWIG_Py_Void();
31724 return resultobj;
31725 fail:
31726 return NULL;
31727 }
31728
31729
31730 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31731 PyObject *resultobj = 0;
31732 wxWindow *arg1 = (wxWindow *) 0 ;
31733 int result;
31734 void *argp1 = 0 ;
31735 int res1 = 0 ;
31736 PyObject *swig_obj[1] ;
31737
31738 if (!args) SWIG_fail;
31739 swig_obj[0] = args;
31740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31741 if (!SWIG_IsOK(res1)) {
31742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31743 }
31744 arg1 = reinterpret_cast< wxWindow * >(argp1);
31745 {
31746 PyThreadState* __tstate = wxPyBeginAllowThreads();
31747 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31748 wxPyEndAllowThreads(__tstate);
31749 if (PyErr_Occurred()) SWIG_fail;
31750 }
31751 resultobj = SWIG_From_int(static_cast< int >(result));
31752 return resultobj;
31753 fail:
31754 return NULL;
31755 }
31756
31757
31758 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31759 PyObject *resultobj = 0;
31760 wxWindow *arg1 = (wxWindow *) 0 ;
31761 int result;
31762 void *argp1 = 0 ;
31763 int res1 = 0 ;
31764 PyObject *swig_obj[1] ;
31765
31766 if (!args) SWIG_fail;
31767 swig_obj[0] = args;
31768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31769 if (!SWIG_IsOK(res1)) {
31770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31771 }
31772 arg1 = reinterpret_cast< wxWindow * >(argp1);
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 resultobj = SWIG_From_int(static_cast< int >(result));
31780 return resultobj;
31781 fail:
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 wxWindow *arg1 = (wxWindow *) 0 ;
31789 int result;
31790 void *argp1 = 0 ;
31791 int res1 = 0 ;
31792 PyObject *swig_obj[1] ;
31793
31794 if (!args) SWIG_fail;
31795 swig_obj[0] = args;
31796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31797 if (!SWIG_IsOK(res1)) {
31798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31799 }
31800 arg1 = reinterpret_cast< wxWindow * >(argp1);
31801 {
31802 PyThreadState* __tstate = wxPyBeginAllowThreads();
31803 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 resultobj = SWIG_From_int(static_cast< int >(result));
31808 return resultobj;
31809 fail:
31810 return NULL;
31811 }
31812
31813
31814 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31815 PyObject *resultobj = 0;
31816 wxWindow *arg1 = (wxWindow *) 0 ;
31817 int result;
31818 void *argp1 = 0 ;
31819 int res1 = 0 ;
31820 PyObject *swig_obj[1] ;
31821
31822 if (!args) SWIG_fail;
31823 swig_obj[0] = args;
31824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31827 }
31828 arg1 = reinterpret_cast< wxWindow * >(argp1);
31829 {
31830 PyThreadState* __tstate = wxPyBeginAllowThreads();
31831 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 resultobj = SWIG_From_int(static_cast< int >(result));
31836 return resultobj;
31837 fail:
31838 return NULL;
31839 }
31840
31841
31842 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31843 PyObject *resultobj = 0;
31844 wxWindow *arg1 = (wxWindow *) 0 ;
31845 wxSize *arg2 = 0 ;
31846 void *argp1 = 0 ;
31847 int res1 = 0 ;
31848 wxSize temp2 ;
31849 PyObject * obj0 = 0 ;
31850 PyObject * obj1 = 0 ;
31851 char * kwnames[] = {
31852 (char *) "self",(char *) "size", NULL
31853 };
31854
31855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31857 if (!SWIG_IsOK(res1)) {
31858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31859 }
31860 arg1 = reinterpret_cast< wxWindow * >(argp1);
31861 {
31862 arg2 = &temp2;
31863 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31864 }
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_Py_Void();
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31879 PyObject *resultobj = 0;
31880 wxWindow *arg1 = (wxWindow *) 0 ;
31881 int arg2 ;
31882 int arg3 ;
31883 void *argp1 = 0 ;
31884 int res1 = 0 ;
31885 int val2 ;
31886 int ecode2 = 0 ;
31887 int val3 ;
31888 int ecode3 = 0 ;
31889 PyObject * obj0 = 0 ;
31890 PyObject * obj1 = 0 ;
31891 PyObject * obj2 = 0 ;
31892 char * kwnames[] = {
31893 (char *) "self",(char *) "w",(char *) "h", NULL
31894 };
31895
31896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31898 if (!SWIG_IsOK(res1)) {
31899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31900 }
31901 arg1 = reinterpret_cast< wxWindow * >(argp1);
31902 ecode2 = SWIG_AsVal_int(obj1, &val2);
31903 if (!SWIG_IsOK(ecode2)) {
31904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31905 }
31906 arg2 = static_cast< int >(val2);
31907 ecode3 = SWIG_AsVal_int(obj2, &val3);
31908 if (!SWIG_IsOK(ecode3)) {
31909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31910 }
31911 arg3 = static_cast< int >(val3);
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 (arg1)->SetVirtualSize(arg2,arg3);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31926 PyObject *resultobj = 0;
31927 wxWindow *arg1 = (wxWindow *) 0 ;
31928 wxSize result;
31929 void *argp1 = 0 ;
31930 int res1 = 0 ;
31931 PyObject *swig_obj[1] ;
31932
31933 if (!args) SWIG_fail;
31934 swig_obj[0] = args;
31935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31936 if (!SWIG_IsOK(res1)) {
31937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31938 }
31939 arg1 = reinterpret_cast< wxWindow * >(argp1);
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 result = ((wxWindow const *)arg1)->GetVirtualSize();
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 PyObject *resultobj = 0;
31955 wxWindow *arg1 = (wxWindow *) 0 ;
31956 int *arg2 = (int *) 0 ;
31957 int *arg3 = (int *) 0 ;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 int temp2 ;
31961 int res2 = SWIG_TMPOBJ ;
31962 int temp3 ;
31963 int res3 = SWIG_TMPOBJ ;
31964 PyObject *swig_obj[1] ;
31965
31966 arg2 = &temp2;
31967 arg3 = &temp3;
31968 if (!args) SWIG_fail;
31969 swig_obj[0] = args;
31970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31971 if (!SWIG_IsOK(res1)) {
31972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31973 }
31974 arg1 = reinterpret_cast< wxWindow * >(argp1);
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31978 wxPyEndAllowThreads(__tstate);
31979 if (PyErr_Occurred()) SWIG_fail;
31980 }
31981 resultobj = SWIG_Py_Void();
31982 if (SWIG_IsTmpObj(res2)) {
31983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31984 } else {
31985 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31987 }
31988 if (SWIG_IsTmpObj(res3)) {
31989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31990 } else {
31991 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31993 }
31994 return resultobj;
31995 fail:
31996 return NULL;
31997 }
31998
31999
32000 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32001 PyObject *resultobj = 0;
32002 wxWindow *arg1 = (wxWindow *) 0 ;
32003 wxSize result;
32004 void *argp1 = 0 ;
32005 int res1 = 0 ;
32006 PyObject *swig_obj[1] ;
32007
32008 if (!args) SWIG_fail;
32009 swig_obj[0] = args;
32010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32011 if (!SWIG_IsOK(res1)) {
32012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32013 }
32014 arg1 = reinterpret_cast< wxWindow * >(argp1);
32015 {
32016 PyThreadState* __tstate = wxPyBeginAllowThreads();
32017 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32018 wxPyEndAllowThreads(__tstate);
32019 if (PyErr_Occurred()) SWIG_fail;
32020 }
32021 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32022 return resultobj;
32023 fail:
32024 return NULL;
32025 }
32026
32027
32028 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32029 PyObject *resultobj = 0;
32030 wxWindow *arg1 = (wxWindow *) 0 ;
32031 bool arg2 = (bool) true ;
32032 bool result;
32033 void *argp1 = 0 ;
32034 int res1 = 0 ;
32035 bool val2 ;
32036 int ecode2 = 0 ;
32037 PyObject * obj0 = 0 ;
32038 PyObject * obj1 = 0 ;
32039 char * kwnames[] = {
32040 (char *) "self",(char *) "show", NULL
32041 };
32042
32043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32045 if (!SWIG_IsOK(res1)) {
32046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32047 }
32048 arg1 = reinterpret_cast< wxWindow * >(argp1);
32049 if (obj1) {
32050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32051 if (!SWIG_IsOK(ecode2)) {
32052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32053 }
32054 arg2 = static_cast< bool >(val2);
32055 }
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 result = (bool)(arg1)->Show(arg2);
32059 wxPyEndAllowThreads(__tstate);
32060 if (PyErr_Occurred()) SWIG_fail;
32061 }
32062 {
32063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32064 }
32065 return resultobj;
32066 fail:
32067 return NULL;
32068 }
32069
32070
32071 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32072 PyObject *resultobj = 0;
32073 wxWindow *arg1 = (wxWindow *) 0 ;
32074 bool result;
32075 void *argp1 = 0 ;
32076 int res1 = 0 ;
32077 PyObject *swig_obj[1] ;
32078
32079 if (!args) SWIG_fail;
32080 swig_obj[0] = args;
32081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32082 if (!SWIG_IsOK(res1)) {
32083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32084 }
32085 arg1 = reinterpret_cast< wxWindow * >(argp1);
32086 {
32087 PyThreadState* __tstate = wxPyBeginAllowThreads();
32088 result = (bool)(arg1)->Hide();
32089 wxPyEndAllowThreads(__tstate);
32090 if (PyErr_Occurred()) SWIG_fail;
32091 }
32092 {
32093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32094 }
32095 return resultobj;
32096 fail:
32097 return NULL;
32098 }
32099
32100
32101 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32102 PyObject *resultobj = 0;
32103 wxWindow *arg1 = (wxWindow *) 0 ;
32104 bool arg2 = (bool) true ;
32105 bool result;
32106 void *argp1 = 0 ;
32107 int res1 = 0 ;
32108 bool val2 ;
32109 int ecode2 = 0 ;
32110 PyObject * obj0 = 0 ;
32111 PyObject * obj1 = 0 ;
32112 char * kwnames[] = {
32113 (char *) "self",(char *) "enable", NULL
32114 };
32115
32116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32118 if (!SWIG_IsOK(res1)) {
32119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32120 }
32121 arg1 = reinterpret_cast< wxWindow * >(argp1);
32122 if (obj1) {
32123 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32124 if (!SWIG_IsOK(ecode2)) {
32125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32126 }
32127 arg2 = static_cast< bool >(val2);
32128 }
32129 {
32130 PyThreadState* __tstate = wxPyBeginAllowThreads();
32131 result = (bool)(arg1)->Enable(arg2);
32132 wxPyEndAllowThreads(__tstate);
32133 if (PyErr_Occurred()) SWIG_fail;
32134 }
32135 {
32136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32137 }
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32145 PyObject *resultobj = 0;
32146 wxWindow *arg1 = (wxWindow *) 0 ;
32147 bool result;
32148 void *argp1 = 0 ;
32149 int res1 = 0 ;
32150 PyObject *swig_obj[1] ;
32151
32152 if (!args) SWIG_fail;
32153 swig_obj[0] = args;
32154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32155 if (!SWIG_IsOK(res1)) {
32156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32157 }
32158 arg1 = reinterpret_cast< wxWindow * >(argp1);
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (bool)(arg1)->Disable();
32162 wxPyEndAllowThreads(__tstate);
32163 if (PyErr_Occurred()) SWIG_fail;
32164 }
32165 {
32166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32167 }
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32175 PyObject *resultobj = 0;
32176 wxWindow *arg1 = (wxWindow *) 0 ;
32177 bool result;
32178 void *argp1 = 0 ;
32179 int res1 = 0 ;
32180 PyObject *swig_obj[1] ;
32181
32182 if (!args) SWIG_fail;
32183 swig_obj[0] = args;
32184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32185 if (!SWIG_IsOK(res1)) {
32186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32187 }
32188 arg1 = reinterpret_cast< wxWindow * >(argp1);
32189 {
32190 PyThreadState* __tstate = wxPyBeginAllowThreads();
32191 result = (bool)((wxWindow const *)arg1)->IsShown();
32192 wxPyEndAllowThreads(__tstate);
32193 if (PyErr_Occurred()) SWIG_fail;
32194 }
32195 {
32196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32197 }
32198 return resultobj;
32199 fail:
32200 return NULL;
32201 }
32202
32203
32204 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32205 PyObject *resultobj = 0;
32206 wxWindow *arg1 = (wxWindow *) 0 ;
32207 bool result;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 PyObject *swig_obj[1] ;
32211
32212 if (!args) SWIG_fail;
32213 swig_obj[0] = args;
32214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32215 if (!SWIG_IsOK(res1)) {
32216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32217 }
32218 arg1 = reinterpret_cast< wxWindow * >(argp1);
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32222 wxPyEndAllowThreads(__tstate);
32223 if (PyErr_Occurred()) SWIG_fail;
32224 }
32225 {
32226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32227 }
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 long arg2 ;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 long val2 ;
32241 int ecode2 = 0 ;
32242 PyObject * obj0 = 0 ;
32243 PyObject * obj1 = 0 ;
32244 char * kwnames[] = {
32245 (char *) "self",(char *) "style", NULL
32246 };
32247
32248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32250 if (!SWIG_IsOK(res1)) {
32251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32252 }
32253 arg1 = reinterpret_cast< wxWindow * >(argp1);
32254 ecode2 = SWIG_AsVal_long(obj1, &val2);
32255 if (!SWIG_IsOK(ecode2)) {
32256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32257 }
32258 arg2 = static_cast< long >(val2);
32259 {
32260 PyThreadState* __tstate = wxPyBeginAllowThreads();
32261 (arg1)->SetWindowStyleFlag(arg2);
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 resultobj = SWIG_Py_Void();
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32273 PyObject *resultobj = 0;
32274 wxWindow *arg1 = (wxWindow *) 0 ;
32275 long result;
32276 void *argp1 = 0 ;
32277 int res1 = 0 ;
32278 PyObject *swig_obj[1] ;
32279
32280 if (!args) SWIG_fail;
32281 swig_obj[0] = args;
32282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32283 if (!SWIG_IsOK(res1)) {
32284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32285 }
32286 arg1 = reinterpret_cast< wxWindow * >(argp1);
32287 {
32288 PyThreadState* __tstate = wxPyBeginAllowThreads();
32289 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32290 wxPyEndAllowThreads(__tstate);
32291 if (PyErr_Occurred()) SWIG_fail;
32292 }
32293 resultobj = SWIG_From_long(static_cast< long >(result));
32294 return resultobj;
32295 fail:
32296 return NULL;
32297 }
32298
32299
32300 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj = 0;
32302 wxWindow *arg1 = (wxWindow *) 0 ;
32303 int arg2 ;
32304 bool result;
32305 void *argp1 = 0 ;
32306 int res1 = 0 ;
32307 int val2 ;
32308 int ecode2 = 0 ;
32309 PyObject * obj0 = 0 ;
32310 PyObject * obj1 = 0 ;
32311 char * kwnames[] = {
32312 (char *) "self",(char *) "flag", NULL
32313 };
32314
32315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32317 if (!SWIG_IsOK(res1)) {
32318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32319 }
32320 arg1 = reinterpret_cast< wxWindow * >(argp1);
32321 ecode2 = SWIG_AsVal_int(obj1, &val2);
32322 if (!SWIG_IsOK(ecode2)) {
32323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32324 }
32325 arg2 = static_cast< int >(val2);
32326 {
32327 PyThreadState* __tstate = wxPyBeginAllowThreads();
32328 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32329 wxPyEndAllowThreads(__tstate);
32330 if (PyErr_Occurred()) SWIG_fail;
32331 }
32332 {
32333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32334 }
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32342 PyObject *resultobj = 0;
32343 wxWindow *arg1 = (wxWindow *) 0 ;
32344 bool result;
32345 void *argp1 = 0 ;
32346 int res1 = 0 ;
32347 PyObject *swig_obj[1] ;
32348
32349 if (!args) SWIG_fail;
32350 swig_obj[0] = args;
32351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32352 if (!SWIG_IsOK(res1)) {
32353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32354 }
32355 arg1 = reinterpret_cast< wxWindow * >(argp1);
32356 {
32357 PyThreadState* __tstate = wxPyBeginAllowThreads();
32358 result = (bool)((wxWindow const *)arg1)->IsRetained();
32359 wxPyEndAllowThreads(__tstate);
32360 if (PyErr_Occurred()) SWIG_fail;
32361 }
32362 {
32363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32364 }
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32372 PyObject *resultobj = 0;
32373 wxWindow *arg1 = (wxWindow *) 0 ;
32374 long arg2 ;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 long val2 ;
32378 int ecode2 = 0 ;
32379 PyObject * obj0 = 0 ;
32380 PyObject * obj1 = 0 ;
32381 char * kwnames[] = {
32382 (char *) "self",(char *) "exStyle", NULL
32383 };
32384
32385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32387 if (!SWIG_IsOK(res1)) {
32388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32389 }
32390 arg1 = reinterpret_cast< wxWindow * >(argp1);
32391 ecode2 = SWIG_AsVal_long(obj1, &val2);
32392 if (!SWIG_IsOK(ecode2)) {
32393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32394 }
32395 arg2 = static_cast< long >(val2);
32396 {
32397 PyThreadState* __tstate = wxPyBeginAllowThreads();
32398 (arg1)->SetExtraStyle(arg2);
32399 wxPyEndAllowThreads(__tstate);
32400 if (PyErr_Occurred()) SWIG_fail;
32401 }
32402 resultobj = SWIG_Py_Void();
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxWindow *arg1 = (wxWindow *) 0 ;
32412 long result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxWindow * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 resultobj = SWIG_From_long(static_cast< long >(result));
32431 return resultobj;
32432 fail:
32433 return NULL;
32434 }
32435
32436
32437 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32438 PyObject *resultobj = 0;
32439 wxWindow *arg1 = (wxWindow *) 0 ;
32440 bool arg2 = (bool) true ;
32441 void *argp1 = 0 ;
32442 int res1 = 0 ;
32443 bool val2 ;
32444 int ecode2 = 0 ;
32445 PyObject * obj0 = 0 ;
32446 PyObject * obj1 = 0 ;
32447 char * kwnames[] = {
32448 (char *) "self",(char *) "modal", NULL
32449 };
32450
32451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32453 if (!SWIG_IsOK(res1)) {
32454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32455 }
32456 arg1 = reinterpret_cast< wxWindow * >(argp1);
32457 if (obj1) {
32458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32459 if (!SWIG_IsOK(ecode2)) {
32460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32461 }
32462 arg2 = static_cast< bool >(val2);
32463 }
32464 {
32465 PyThreadState* __tstate = wxPyBeginAllowThreads();
32466 (arg1)->MakeModal(arg2);
32467 wxPyEndAllowThreads(__tstate);
32468 if (PyErr_Occurred()) SWIG_fail;
32469 }
32470 resultobj = SWIG_Py_Void();
32471 return resultobj;
32472 fail:
32473 return NULL;
32474 }
32475
32476
32477 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32478 PyObject *resultobj = 0;
32479 wxWindow *arg1 = (wxWindow *) 0 ;
32480 bool arg2 ;
32481 void *argp1 = 0 ;
32482 int res1 = 0 ;
32483 bool val2 ;
32484 int ecode2 = 0 ;
32485 PyObject * obj0 = 0 ;
32486 PyObject * obj1 = 0 ;
32487 char * kwnames[] = {
32488 (char *) "self",(char *) "enableTheme", NULL
32489 };
32490
32491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32493 if (!SWIG_IsOK(res1)) {
32494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32495 }
32496 arg1 = reinterpret_cast< wxWindow * >(argp1);
32497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32498 if (!SWIG_IsOK(ecode2)) {
32499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32500 }
32501 arg2 = static_cast< bool >(val2);
32502 {
32503 PyThreadState* __tstate = wxPyBeginAllowThreads();
32504 (arg1)->SetThemeEnabled(arg2);
32505 wxPyEndAllowThreads(__tstate);
32506 if (PyErr_Occurred()) SWIG_fail;
32507 }
32508 resultobj = SWIG_Py_Void();
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxWindow *arg1 = (wxWindow *) 0 ;
32518 bool result;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 PyObject *swig_obj[1] ;
32522
32523 if (!args) SWIG_fail;
32524 swig_obj[0] = args;
32525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32526 if (!SWIG_IsOK(res1)) {
32527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32528 }
32529 arg1 = reinterpret_cast< wxWindow * >(argp1);
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 {
32537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32538 }
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32546 PyObject *resultobj = 0;
32547 wxWindow *arg1 = (wxWindow *) 0 ;
32548 void *argp1 = 0 ;
32549 int res1 = 0 ;
32550 PyObject *swig_obj[1] ;
32551
32552 if (!args) SWIG_fail;
32553 swig_obj[0] = args;
32554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32555 if (!SWIG_IsOK(res1)) {
32556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32557 }
32558 arg1 = reinterpret_cast< wxWindow * >(argp1);
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 (arg1)->SetFocus();
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 resultobj = SWIG_Py_Void();
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32573 PyObject *resultobj = 0;
32574 wxWindow *arg1 = (wxWindow *) 0 ;
32575 void *argp1 = 0 ;
32576 int res1 = 0 ;
32577 PyObject *swig_obj[1] ;
32578
32579 if (!args) SWIG_fail;
32580 swig_obj[0] = args;
32581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32582 if (!SWIG_IsOK(res1)) {
32583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32584 }
32585 arg1 = reinterpret_cast< wxWindow * >(argp1);
32586 {
32587 PyThreadState* __tstate = wxPyBeginAllowThreads();
32588 (arg1)->SetFocusFromKbd();
32589 wxPyEndAllowThreads(__tstate);
32590 if (PyErr_Occurred()) SWIG_fail;
32591 }
32592 resultobj = SWIG_Py_Void();
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 PyObject *resultobj = 0;
32601 wxWindow *result = 0 ;
32602
32603 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32604 {
32605 if (!wxPyCheckForApp()) SWIG_fail;
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (wxWindow *)wxWindow::FindFocus();
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 {
32612 resultobj = wxPyMake_wxObject(result, 0);
32613 }
32614 return resultobj;
32615 fail:
32616 return NULL;
32617 }
32618
32619
32620 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32621 PyObject *resultobj = 0;
32622 wxWindow *arg1 = (wxWindow *) 0 ;
32623 bool result;
32624 void *argp1 = 0 ;
32625 int res1 = 0 ;
32626 PyObject *swig_obj[1] ;
32627
32628 if (!args) SWIG_fail;
32629 swig_obj[0] = args;
32630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32631 if (!SWIG_IsOK(res1)) {
32632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32633 }
32634 arg1 = reinterpret_cast< wxWindow * >(argp1);
32635 {
32636 PyThreadState* __tstate = wxPyBeginAllowThreads();
32637 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32638 wxPyEndAllowThreads(__tstate);
32639 if (PyErr_Occurred()) SWIG_fail;
32640 }
32641 {
32642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32643 }
32644 return resultobj;
32645 fail:
32646 return NULL;
32647 }
32648
32649
32650 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32651 PyObject *resultobj = 0;
32652 wxWindow *arg1 = (wxWindow *) 0 ;
32653 bool result;
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_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32663 }
32664 arg1 = reinterpret_cast< wxWindow * >(argp1);
32665 {
32666 PyThreadState* __tstate = wxPyBeginAllowThreads();
32667 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32668 wxPyEndAllowThreads(__tstate);
32669 if (PyErr_Occurred()) SWIG_fail;
32670 }
32671 {
32672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32673 }
32674 return resultobj;
32675 fail:
32676 return NULL;
32677 }
32678
32679
32680 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32681 PyObject *resultobj = 0;
32682 wxWindow *arg1 = (wxWindow *) 0 ;
32683 wxWindow *result = 0 ;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 PyObject *swig_obj[1] ;
32687
32688 if (!args) SWIG_fail;
32689 swig_obj[0] = args;
32690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32691 if (!SWIG_IsOK(res1)) {
32692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32693 }
32694 arg1 = reinterpret_cast< wxWindow * >(argp1);
32695 {
32696 PyThreadState* __tstate = wxPyBeginAllowThreads();
32697 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32698 wxPyEndAllowThreads(__tstate);
32699 if (PyErr_Occurred()) SWIG_fail;
32700 }
32701 {
32702 resultobj = wxPyMake_wxObject(result, 0);
32703 }
32704 return resultobj;
32705 fail:
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32711 PyObject *resultobj = 0;
32712 wxWindow *arg1 = (wxWindow *) 0 ;
32713 wxWindow *arg2 = (wxWindow *) 0 ;
32714 wxWindow *result = 0 ;
32715 void *argp1 = 0 ;
32716 int res1 = 0 ;
32717 void *argp2 = 0 ;
32718 int res2 = 0 ;
32719 PyObject * obj0 = 0 ;
32720 PyObject * obj1 = 0 ;
32721 char * kwnames[] = {
32722 (char *) "self",(char *) "child", NULL
32723 };
32724
32725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32727 if (!SWIG_IsOK(res1)) {
32728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32729 }
32730 arg1 = reinterpret_cast< wxWindow * >(argp1);
32731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32732 if (!SWIG_IsOK(res2)) {
32733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32734 }
32735 arg2 = reinterpret_cast< wxWindow * >(argp2);
32736 {
32737 PyThreadState* __tstate = wxPyBeginAllowThreads();
32738 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = wxPyMake_wxObject(result, 0);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 wxWindow *arg2 = (wxWindow *) 0 ;
32755 void *argp1 = 0 ;
32756 int res1 = 0 ;
32757 void *argp2 = 0 ;
32758 int res2 = 0 ;
32759 PyObject * obj0 = 0 ;
32760 PyObject * obj1 = 0 ;
32761 char * kwnames[] = {
32762 (char *) "self",(char *) "win", NULL
32763 };
32764
32765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32767 if (!SWIG_IsOK(res1)) {
32768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32769 }
32770 arg1 = reinterpret_cast< wxWindow * >(argp1);
32771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32772 if (!SWIG_IsOK(res2)) {
32773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32774 }
32775 arg2 = reinterpret_cast< wxWindow * >(argp2);
32776 {
32777 PyThreadState* __tstate = wxPyBeginAllowThreads();
32778 (arg1)->SetTmpDefaultItem(arg2);
32779 wxPyEndAllowThreads(__tstate);
32780 if (PyErr_Occurred()) SWIG_fail;
32781 }
32782 resultobj = SWIG_Py_Void();
32783 return resultobj;
32784 fail:
32785 return NULL;
32786 }
32787
32788
32789 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32790 PyObject *resultobj = 0;
32791 wxWindow *arg1 = (wxWindow *) 0 ;
32792 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32793 bool result;
32794 void *argp1 = 0 ;
32795 int res1 = 0 ;
32796 int val2 ;
32797 int ecode2 = 0 ;
32798 PyObject * obj0 = 0 ;
32799 PyObject * obj1 = 0 ;
32800 char * kwnames[] = {
32801 (char *) "self",(char *) "flags", NULL
32802 };
32803
32804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32808 }
32809 arg1 = reinterpret_cast< wxWindow * >(argp1);
32810 if (obj1) {
32811 ecode2 = SWIG_AsVal_int(obj1, &val2);
32812 if (!SWIG_IsOK(ecode2)) {
32813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32814 }
32815 arg2 = static_cast< int >(val2);
32816 }
32817 {
32818 PyThreadState* __tstate = wxPyBeginAllowThreads();
32819 result = (bool)(arg1)->Navigate(arg2);
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 {
32824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32825 }
32826 return resultobj;
32827 fail:
32828 return NULL;
32829 }
32830
32831
32832 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32833 PyObject *resultobj = 0;
32834 wxWindow *arg1 = (wxWindow *) 0 ;
32835 wxWindow *arg2 = (wxWindow *) 0 ;
32836 void *argp1 = 0 ;
32837 int res1 = 0 ;
32838 void *argp2 = 0 ;
32839 int res2 = 0 ;
32840 PyObject * obj0 = 0 ;
32841 PyObject * obj1 = 0 ;
32842 char * kwnames[] = {
32843 (char *) "self",(char *) "win", NULL
32844 };
32845
32846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32848 if (!SWIG_IsOK(res1)) {
32849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32850 }
32851 arg1 = reinterpret_cast< wxWindow * >(argp1);
32852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32853 if (!SWIG_IsOK(res2)) {
32854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32855 }
32856 arg2 = reinterpret_cast< wxWindow * >(argp2);
32857 {
32858 PyThreadState* __tstate = wxPyBeginAllowThreads();
32859 (arg1)->MoveAfterInTabOrder(arg2);
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 resultobj = SWIG_Py_Void();
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 wxWindow *arg2 = (wxWindow *) 0 ;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 void *argp2 = 0 ;
32877 int res2 = 0 ;
32878 PyObject * obj0 = 0 ;
32879 PyObject * obj1 = 0 ;
32880 char * kwnames[] = {
32881 (char *) "self",(char *) "win", NULL
32882 };
32883
32884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32886 if (!SWIG_IsOK(res1)) {
32887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32888 }
32889 arg1 = reinterpret_cast< wxWindow * >(argp1);
32890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32891 if (!SWIG_IsOK(res2)) {
32892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32893 }
32894 arg2 = reinterpret_cast< wxWindow * >(argp2);
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 (arg1)->MoveBeforeInTabOrder(arg2);
32898 wxPyEndAllowThreads(__tstate);
32899 if (PyErr_Occurred()) SWIG_fail;
32900 }
32901 resultobj = SWIG_Py_Void();
32902 return resultobj;
32903 fail:
32904 return NULL;
32905 }
32906
32907
32908 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32909 PyObject *resultobj = 0;
32910 wxWindow *arg1 = (wxWindow *) 0 ;
32911 PyObject *result = 0 ;
32912 void *argp1 = 0 ;
32913 int res1 = 0 ;
32914 PyObject *swig_obj[1] ;
32915
32916 if (!args) SWIG_fail;
32917 swig_obj[0] = args;
32918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32919 if (!SWIG_IsOK(res1)) {
32920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32921 }
32922 arg1 = reinterpret_cast< wxWindow * >(argp1);
32923 {
32924 PyThreadState* __tstate = wxPyBeginAllowThreads();
32925 result = (PyObject *)wxWindow_GetChildren(arg1);
32926 wxPyEndAllowThreads(__tstate);
32927 if (PyErr_Occurred()) SWIG_fail;
32928 }
32929 resultobj = result;
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32937 PyObject *resultobj = 0;
32938 wxWindow *arg1 = (wxWindow *) 0 ;
32939 wxWindow *result = 0 ;
32940 void *argp1 = 0 ;
32941 int res1 = 0 ;
32942 PyObject *swig_obj[1] ;
32943
32944 if (!args) SWIG_fail;
32945 swig_obj[0] = args;
32946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 {
32952 PyThreadState* __tstate = wxPyBeginAllowThreads();
32953 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32954 wxPyEndAllowThreads(__tstate);
32955 if (PyErr_Occurred()) SWIG_fail;
32956 }
32957 {
32958 resultobj = wxPyMake_wxObject(result, 0);
32959 }
32960 return resultobj;
32961 fail:
32962 return NULL;
32963 }
32964
32965
32966 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32967 PyObject *resultobj = 0;
32968 wxWindow *arg1 = (wxWindow *) 0 ;
32969 wxWindow *result = 0 ;
32970 void *argp1 = 0 ;
32971 int res1 = 0 ;
32972 PyObject *swig_obj[1] ;
32973
32974 if (!args) SWIG_fail;
32975 swig_obj[0] = args;
32976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 {
32982 PyThreadState* __tstate = wxPyBeginAllowThreads();
32983 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32984 wxPyEndAllowThreads(__tstate);
32985 if (PyErr_Occurred()) SWIG_fail;
32986 }
32987 {
32988 resultobj = wxPyMake_wxObject(result, 0);
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32997 PyObject *resultobj = 0;
32998 wxWindow *arg1 = (wxWindow *) 0 ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 PyObject *swig_obj[1] ;
33003
33004 if (!args) SWIG_fail;
33005 swig_obj[0] = args;
33006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res1)) {
33008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33009 }
33010 arg1 = reinterpret_cast< wxWindow * >(argp1);
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 {
33018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33019 }
33020 return resultobj;
33021 fail:
33022 return NULL;
33023 }
33024
33025
33026 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33027 PyObject *resultobj = 0;
33028 wxWindow *arg1 = (wxWindow *) 0 ;
33029 wxWindow *arg2 = (wxWindow *) 0 ;
33030 bool result;
33031 void *argp1 = 0 ;
33032 int res1 = 0 ;
33033 void *argp2 = 0 ;
33034 int res2 = 0 ;
33035 PyObject * obj0 = 0 ;
33036 PyObject * obj1 = 0 ;
33037 char * kwnames[] = {
33038 (char *) "self",(char *) "newParent", NULL
33039 };
33040
33041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33043 if (!SWIG_IsOK(res1)) {
33044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33045 }
33046 arg1 = reinterpret_cast< wxWindow * >(argp1);
33047 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33048 if (!SWIG_IsOK(res2)) {
33049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33050 }
33051 arg2 = reinterpret_cast< wxWindow * >(argp2);
33052 {
33053 PyThreadState* __tstate = wxPyBeginAllowThreads();
33054 result = (bool)(arg1)->Reparent(arg2);
33055 wxPyEndAllowThreads(__tstate);
33056 if (PyErr_Occurred()) SWIG_fail;
33057 }
33058 {
33059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33060 }
33061 return resultobj;
33062 fail:
33063 return NULL;
33064 }
33065
33066
33067 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj = 0;
33069 wxWindow *arg1 = (wxWindow *) 0 ;
33070 wxWindow *arg2 = (wxWindow *) 0 ;
33071 void *argp1 = 0 ;
33072 int res1 = 0 ;
33073 void *argp2 = 0 ;
33074 int res2 = 0 ;
33075 PyObject * obj0 = 0 ;
33076 PyObject * obj1 = 0 ;
33077 char * kwnames[] = {
33078 (char *) "self",(char *) "child", NULL
33079 };
33080
33081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33083 if (!SWIG_IsOK(res1)) {
33084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33085 }
33086 arg1 = reinterpret_cast< wxWindow * >(argp1);
33087 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res2)) {
33089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33090 }
33091 arg2 = reinterpret_cast< wxWindow * >(argp2);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 (arg1)->AddChild(arg2);
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 resultobj = SWIG_Py_Void();
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = 0;
33107 wxWindow *arg1 = (wxWindow *) 0 ;
33108 wxWindow *arg2 = (wxWindow *) 0 ;
33109 void *argp1 = 0 ;
33110 int res1 = 0 ;
33111 void *argp2 = 0 ;
33112 int res2 = 0 ;
33113 PyObject * obj0 = 0 ;
33114 PyObject * obj1 = 0 ;
33115 char * kwnames[] = {
33116 (char *) "self",(char *) "child", NULL
33117 };
33118
33119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33121 if (!SWIG_IsOK(res1)) {
33122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33123 }
33124 arg1 = reinterpret_cast< wxWindow * >(argp1);
33125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33126 if (!SWIG_IsOK(res2)) {
33127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33128 }
33129 arg2 = reinterpret_cast< wxWindow * >(argp2);
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 (arg1)->RemoveChild(arg2);
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 resultobj = SWIG_Py_Void();
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33144 PyObject *resultobj = 0;
33145 wxWindow *arg1 = (wxWindow *) 0 ;
33146 long arg2 ;
33147 wxWindow *result = 0 ;
33148 void *argp1 = 0 ;
33149 int res1 = 0 ;
33150 long val2 ;
33151 int ecode2 = 0 ;
33152 PyObject * obj0 = 0 ;
33153 PyObject * obj1 = 0 ;
33154 char * kwnames[] = {
33155 (char *) "self",(char *) "winid", NULL
33156 };
33157
33158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33160 if (!SWIG_IsOK(res1)) {
33161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33162 }
33163 arg1 = reinterpret_cast< wxWindow * >(argp1);
33164 ecode2 = SWIG_AsVal_long(obj1, &val2);
33165 if (!SWIG_IsOK(ecode2)) {
33166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33167 }
33168 arg2 = static_cast< long >(val2);
33169 {
33170 PyThreadState* __tstate = wxPyBeginAllowThreads();
33171 result = (wxWindow *)(arg1)->FindWindow(arg2);
33172 wxPyEndAllowThreads(__tstate);
33173 if (PyErr_Occurred()) SWIG_fail;
33174 }
33175 {
33176 resultobj = wxPyMake_wxObject(result, 0);
33177 }
33178 return resultobj;
33179 fail:
33180 return NULL;
33181 }
33182
33183
33184 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33185 PyObject *resultobj = 0;
33186 wxWindow *arg1 = (wxWindow *) 0 ;
33187 wxString *arg2 = 0 ;
33188 wxWindow *result = 0 ;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 bool temp2 = false ;
33192 PyObject * obj0 = 0 ;
33193 PyObject * obj1 = 0 ;
33194 char * kwnames[] = {
33195 (char *) "self",(char *) "name", NULL
33196 };
33197
33198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33200 if (!SWIG_IsOK(res1)) {
33201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33202 }
33203 arg1 = reinterpret_cast< wxWindow * >(argp1);
33204 {
33205 arg2 = wxString_in_helper(obj1);
33206 if (arg2 == NULL) SWIG_fail;
33207 temp2 = true;
33208 }
33209 {
33210 PyThreadState* __tstate = wxPyBeginAllowThreads();
33211 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33212 wxPyEndAllowThreads(__tstate);
33213 if (PyErr_Occurred()) SWIG_fail;
33214 }
33215 {
33216 resultobj = wxPyMake_wxObject(result, 0);
33217 }
33218 {
33219 if (temp2)
33220 delete arg2;
33221 }
33222 return resultobj;
33223 fail:
33224 {
33225 if (temp2)
33226 delete arg2;
33227 }
33228 return NULL;
33229 }
33230
33231
33232 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33233 PyObject *resultobj = 0;
33234 wxWindow *arg1 = (wxWindow *) 0 ;
33235 wxEvtHandler *result = 0 ;
33236 void *argp1 = 0 ;
33237 int res1 = 0 ;
33238 PyObject *swig_obj[1] ;
33239
33240 if (!args) SWIG_fail;
33241 swig_obj[0] = args;
33242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33245 }
33246 arg1 = reinterpret_cast< wxWindow * >(argp1);
33247 {
33248 PyThreadState* __tstate = wxPyBeginAllowThreads();
33249 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33250 wxPyEndAllowThreads(__tstate);
33251 if (PyErr_Occurred()) SWIG_fail;
33252 }
33253 {
33254 resultobj = wxPyMake_wxObject(result, 0);
33255 }
33256 return resultobj;
33257 fail:
33258 return NULL;
33259 }
33260
33261
33262 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33263 PyObject *resultobj = 0;
33264 wxWindow *arg1 = (wxWindow *) 0 ;
33265 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33266 void *argp1 = 0 ;
33267 int res1 = 0 ;
33268 void *argp2 = 0 ;
33269 int res2 = 0 ;
33270 PyObject * obj0 = 0 ;
33271 PyObject * obj1 = 0 ;
33272 char * kwnames[] = {
33273 (char *) "self",(char *) "handler", NULL
33274 };
33275
33276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33278 if (!SWIG_IsOK(res1)) {
33279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33280 }
33281 arg1 = reinterpret_cast< wxWindow * >(argp1);
33282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33283 if (!SWIG_IsOK(res2)) {
33284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33285 }
33286 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33287 {
33288 PyThreadState* __tstate = wxPyBeginAllowThreads();
33289 (arg1)->SetEventHandler(arg2);
33290 wxPyEndAllowThreads(__tstate);
33291 if (PyErr_Occurred()) SWIG_fail;
33292 }
33293 resultobj = SWIG_Py_Void();
33294 return resultobj;
33295 fail:
33296 return NULL;
33297 }
33298
33299
33300 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33301 PyObject *resultobj = 0;
33302 wxWindow *arg1 = (wxWindow *) 0 ;
33303 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33304 void *argp1 = 0 ;
33305 int res1 = 0 ;
33306 void *argp2 = 0 ;
33307 int res2 = 0 ;
33308 PyObject * obj0 = 0 ;
33309 PyObject * obj1 = 0 ;
33310 char * kwnames[] = {
33311 (char *) "self",(char *) "handler", NULL
33312 };
33313
33314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33316 if (!SWIG_IsOK(res1)) {
33317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33318 }
33319 arg1 = reinterpret_cast< wxWindow * >(argp1);
33320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33321 if (!SWIG_IsOK(res2)) {
33322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33323 }
33324 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33325 {
33326 PyThreadState* __tstate = wxPyBeginAllowThreads();
33327 (arg1)->PushEventHandler(arg2);
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 resultobj = SWIG_Py_Void();
33332 return resultobj;
33333 fail:
33334 return NULL;
33335 }
33336
33337
33338 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33339 PyObject *resultobj = 0;
33340 wxWindow *arg1 = (wxWindow *) 0 ;
33341 bool arg2 = (bool) false ;
33342 wxEvtHandler *result = 0 ;
33343 void *argp1 = 0 ;
33344 int res1 = 0 ;
33345 bool val2 ;
33346 int ecode2 = 0 ;
33347 PyObject * obj0 = 0 ;
33348 PyObject * obj1 = 0 ;
33349 char * kwnames[] = {
33350 (char *) "self",(char *) "deleteHandler", NULL
33351 };
33352
33353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33355 if (!SWIG_IsOK(res1)) {
33356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33357 }
33358 arg1 = reinterpret_cast< wxWindow * >(argp1);
33359 if (obj1) {
33360 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33361 if (!SWIG_IsOK(ecode2)) {
33362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33363 }
33364 arg2 = static_cast< bool >(val2);
33365 }
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33369 wxPyEndAllowThreads(__tstate);
33370 if (PyErr_Occurred()) SWIG_fail;
33371 }
33372 {
33373 resultobj = wxPyMake_wxObject(result, 0);
33374 }
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33382 PyObject *resultobj = 0;
33383 wxWindow *arg1 = (wxWindow *) 0 ;
33384 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33385 bool result;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 void *argp2 = 0 ;
33389 int res2 = 0 ;
33390 PyObject * obj0 = 0 ;
33391 PyObject * obj1 = 0 ;
33392 char * kwnames[] = {
33393 (char *) "self",(char *) "handler", NULL
33394 };
33395
33396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33398 if (!SWIG_IsOK(res1)) {
33399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33400 }
33401 arg1 = reinterpret_cast< wxWindow * >(argp1);
33402 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33403 if (!SWIG_IsOK(res2)) {
33404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33405 }
33406 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (bool)(arg1)->RemoveEventHandler(arg2);
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 {
33414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33415 }
33416 return resultobj;
33417 fail:
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33423 PyObject *resultobj = 0;
33424 wxWindow *arg1 = (wxWindow *) 0 ;
33425 wxValidator *arg2 = 0 ;
33426 void *argp1 = 0 ;
33427 int res1 = 0 ;
33428 void *argp2 = 0 ;
33429 int res2 = 0 ;
33430 PyObject * obj0 = 0 ;
33431 PyObject * obj1 = 0 ;
33432 char * kwnames[] = {
33433 (char *) "self",(char *) "validator", NULL
33434 };
33435
33436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33438 if (!SWIG_IsOK(res1)) {
33439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33440 }
33441 arg1 = reinterpret_cast< wxWindow * >(argp1);
33442 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33443 if (!SWIG_IsOK(res2)) {
33444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33445 }
33446 if (!argp2) {
33447 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33448 }
33449 arg2 = reinterpret_cast< wxValidator * >(argp2);
33450 {
33451 PyThreadState* __tstate = wxPyBeginAllowThreads();
33452 (arg1)->SetValidator((wxValidator const &)*arg2);
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 resultobj = SWIG_Py_Void();
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33464 PyObject *resultobj = 0;
33465 wxWindow *arg1 = (wxWindow *) 0 ;
33466 wxValidator *result = 0 ;
33467 void *argp1 = 0 ;
33468 int res1 = 0 ;
33469 PyObject *swig_obj[1] ;
33470
33471 if (!args) SWIG_fail;
33472 swig_obj[0] = args;
33473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33474 if (!SWIG_IsOK(res1)) {
33475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33476 }
33477 arg1 = reinterpret_cast< wxWindow * >(argp1);
33478 {
33479 PyThreadState* __tstate = wxPyBeginAllowThreads();
33480 result = (wxValidator *)(arg1)->GetValidator();
33481 wxPyEndAllowThreads(__tstate);
33482 if (PyErr_Occurred()) SWIG_fail;
33483 }
33484 {
33485 resultobj = wxPyMake_wxObject(result, (bool)0);
33486 }
33487 return resultobj;
33488 fail:
33489 return NULL;
33490 }
33491
33492
33493 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33494 PyObject *resultobj = 0;
33495 wxWindow *arg1 = (wxWindow *) 0 ;
33496 bool result;
33497 void *argp1 = 0 ;
33498 int res1 = 0 ;
33499 PyObject *swig_obj[1] ;
33500
33501 if (!args) SWIG_fail;
33502 swig_obj[0] = args;
33503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33504 if (!SWIG_IsOK(res1)) {
33505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33506 }
33507 arg1 = reinterpret_cast< wxWindow * >(argp1);
33508 {
33509 PyThreadState* __tstate = wxPyBeginAllowThreads();
33510 result = (bool)(arg1)->Validate();
33511 wxPyEndAllowThreads(__tstate);
33512 if (PyErr_Occurred()) SWIG_fail;
33513 }
33514 {
33515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33516 }
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33524 PyObject *resultobj = 0;
33525 wxWindow *arg1 = (wxWindow *) 0 ;
33526 bool result;
33527 void *argp1 = 0 ;
33528 int res1 = 0 ;
33529 PyObject *swig_obj[1] ;
33530
33531 if (!args) SWIG_fail;
33532 swig_obj[0] = args;
33533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 {
33539 PyThreadState* __tstate = wxPyBeginAllowThreads();
33540 result = (bool)(arg1)->TransferDataToWindow();
33541 wxPyEndAllowThreads(__tstate);
33542 if (PyErr_Occurred()) SWIG_fail;
33543 }
33544 {
33545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33546 }
33547 return resultobj;
33548 fail:
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 bool result;
33557 void *argp1 = 0 ;
33558 int res1 = 0 ;
33559 PyObject *swig_obj[1] ;
33560
33561 if (!args) SWIG_fail;
33562 swig_obj[0] = args;
33563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33564 if (!SWIG_IsOK(res1)) {
33565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33566 }
33567 arg1 = reinterpret_cast< wxWindow * >(argp1);
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (bool)(arg1)->TransferDataFromWindow();
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33576 }
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33584 PyObject *resultobj = 0;
33585 wxWindow *arg1 = (wxWindow *) 0 ;
33586 void *argp1 = 0 ;
33587 int res1 = 0 ;
33588 PyObject *swig_obj[1] ;
33589
33590 if (!args) SWIG_fail;
33591 swig_obj[0] = args;
33592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33593 if (!SWIG_IsOK(res1)) {
33594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33595 }
33596 arg1 = reinterpret_cast< wxWindow * >(argp1);
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 (arg1)->InitDialog();
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 resultobj = SWIG_Py_Void();
33604 return resultobj;
33605 fail:
33606 return NULL;
33607 }
33608
33609
33610 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33611 PyObject *resultobj = 0;
33612 wxWindow *arg1 = (wxWindow *) 0 ;
33613 wxAcceleratorTable *arg2 = 0 ;
33614 void *argp1 = 0 ;
33615 int res1 = 0 ;
33616 void *argp2 = 0 ;
33617 int res2 = 0 ;
33618 PyObject * obj0 = 0 ;
33619 PyObject * obj1 = 0 ;
33620 char * kwnames[] = {
33621 (char *) "self",(char *) "accel", NULL
33622 };
33623
33624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33626 if (!SWIG_IsOK(res1)) {
33627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33628 }
33629 arg1 = reinterpret_cast< wxWindow * >(argp1);
33630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33631 if (!SWIG_IsOK(res2)) {
33632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33633 }
33634 if (!argp2) {
33635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33636 }
33637 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33641 wxPyEndAllowThreads(__tstate);
33642 if (PyErr_Occurred()) SWIG_fail;
33643 }
33644 resultobj = SWIG_Py_Void();
33645 return resultobj;
33646 fail:
33647 return NULL;
33648 }
33649
33650
33651 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33652 PyObject *resultobj = 0;
33653 wxWindow *arg1 = (wxWindow *) 0 ;
33654 wxAcceleratorTable *result = 0 ;
33655 void *argp1 = 0 ;
33656 int res1 = 0 ;
33657 PyObject *swig_obj[1] ;
33658
33659 if (!args) SWIG_fail;
33660 swig_obj[0] = args;
33661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33662 if (!SWIG_IsOK(res1)) {
33663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33664 }
33665 arg1 = reinterpret_cast< wxWindow * >(argp1);
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33669 wxPyEndAllowThreads(__tstate);
33670 if (PyErr_Occurred()) SWIG_fail;
33671 }
33672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33673 return resultobj;
33674 fail:
33675 return NULL;
33676 }
33677
33678
33679 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33680 PyObject *resultobj = 0;
33681 wxWindow *arg1 = (wxWindow *) 0 ;
33682 int arg2 ;
33683 int arg3 ;
33684 int arg4 ;
33685 bool result;
33686 void *argp1 = 0 ;
33687 int res1 = 0 ;
33688 int val2 ;
33689 int ecode2 = 0 ;
33690 int val3 ;
33691 int ecode3 = 0 ;
33692 int val4 ;
33693 int ecode4 = 0 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 PyObject * obj2 = 0 ;
33697 PyObject * obj3 = 0 ;
33698 char * kwnames[] = {
33699 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33700 };
33701
33702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33704 if (!SWIG_IsOK(res1)) {
33705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33706 }
33707 arg1 = reinterpret_cast< wxWindow * >(argp1);
33708 ecode2 = SWIG_AsVal_int(obj1, &val2);
33709 if (!SWIG_IsOK(ecode2)) {
33710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33711 }
33712 arg2 = static_cast< int >(val2);
33713 ecode3 = SWIG_AsVal_int(obj2, &val3);
33714 if (!SWIG_IsOK(ecode3)) {
33715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33716 }
33717 arg3 = static_cast< int >(val3);
33718 ecode4 = SWIG_AsVal_int(obj3, &val4);
33719 if (!SWIG_IsOK(ecode4)) {
33720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33721 }
33722 arg4 = static_cast< int >(val4);
33723 {
33724 PyThreadState* __tstate = wxPyBeginAllowThreads();
33725 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33726 wxPyEndAllowThreads(__tstate);
33727 if (PyErr_Occurred()) SWIG_fail;
33728 }
33729 {
33730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33731 }
33732 return resultobj;
33733 fail:
33734 return NULL;
33735 }
33736
33737
33738 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33739 PyObject *resultobj = 0;
33740 wxWindow *arg1 = (wxWindow *) 0 ;
33741 int arg2 ;
33742 bool result;
33743 void *argp1 = 0 ;
33744 int res1 = 0 ;
33745 int val2 ;
33746 int ecode2 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 PyObject * obj1 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "hotkeyId", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",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_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_int(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33762 }
33763 arg2 = static_cast< int >(val2);
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 {
33771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33772 }
33773 return resultobj;
33774 fail:
33775 return NULL;
33776 }
33777
33778
33779 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33780 PyObject *resultobj = 0;
33781 wxWindow *arg1 = (wxWindow *) 0 ;
33782 wxPoint *arg2 = 0 ;
33783 wxPoint result;
33784 void *argp1 = 0 ;
33785 int res1 = 0 ;
33786 wxPoint temp2 ;
33787 PyObject * obj0 = 0 ;
33788 PyObject * obj1 = 0 ;
33789 char * kwnames[] = {
33790 (char *) "self",(char *) "pt", NULL
33791 };
33792
33793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33795 if (!SWIG_IsOK(res1)) {
33796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33797 }
33798 arg1 = reinterpret_cast< wxWindow * >(argp1);
33799 {
33800 arg2 = &temp2;
33801 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33802 }
33803 {
33804 PyThreadState* __tstate = wxPyBeginAllowThreads();
33805 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 wxSize *arg2 = 0 ;
33820 wxSize result;
33821 void *argp1 = 0 ;
33822 int res1 = 0 ;
33823 wxSize temp2 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 char * kwnames[] = {
33827 (char *) "self",(char *) "sz", NULL
33828 };
33829
33830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33832 if (!SWIG_IsOK(res1)) {
33833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33834 }
33835 arg1 = reinterpret_cast< wxWindow * >(argp1);
33836 {
33837 arg2 = &temp2;
33838 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33839 }
33840 {
33841 PyThreadState* __tstate = wxPyBeginAllowThreads();
33842 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33854 PyObject *resultobj = 0;
33855 wxWindow *arg1 = (wxWindow *) 0 ;
33856 wxPoint *arg2 = 0 ;
33857 wxPoint result;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 wxPoint temp2 ;
33861 PyObject * obj0 = 0 ;
33862 PyObject * obj1 = 0 ;
33863 char * kwnames[] = {
33864 (char *) "self",(char *) "pt", NULL
33865 };
33866
33867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33869 if (!SWIG_IsOK(res1)) {
33870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33871 }
33872 arg1 = reinterpret_cast< wxWindow * >(argp1);
33873 {
33874 arg2 = &temp2;
33875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33876 }
33877 {
33878 PyThreadState* __tstate = wxPyBeginAllowThreads();
33879 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33880 wxPyEndAllowThreads(__tstate);
33881 if (PyErr_Occurred()) SWIG_fail;
33882 }
33883 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33884 return resultobj;
33885 fail:
33886 return NULL;
33887 }
33888
33889
33890 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33891 PyObject *resultobj = 0;
33892 wxWindow *arg1 = (wxWindow *) 0 ;
33893 wxSize *arg2 = 0 ;
33894 wxSize result;
33895 void *argp1 = 0 ;
33896 int res1 = 0 ;
33897 wxSize temp2 ;
33898 PyObject * obj0 = 0 ;
33899 PyObject * obj1 = 0 ;
33900 char * kwnames[] = {
33901 (char *) "self",(char *) "sz", NULL
33902 };
33903
33904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33906 if (!SWIG_IsOK(res1)) {
33907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33908 }
33909 arg1 = reinterpret_cast< wxWindow * >(argp1);
33910 {
33911 arg2 = &temp2;
33912 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33913 }
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33921 return resultobj;
33922 fail:
33923 return NULL;
33924 }
33925
33926
33927 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33928 PyObject *resultobj = 0;
33929 wxWindow *arg1 = (wxWindow *) 0 ;
33930 wxPoint *arg2 = 0 ;
33931 wxPoint result;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 wxPoint temp2 ;
33935 PyObject * obj0 = 0 ;
33936 PyObject * obj1 = 0 ;
33937 char * kwnames[] = {
33938 (char *) "self",(char *) "pt", NULL
33939 };
33940
33941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33943 if (!SWIG_IsOK(res1)) {
33944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33945 }
33946 arg1 = reinterpret_cast< wxWindow * >(argp1);
33947 {
33948 arg2 = &temp2;
33949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33950 }
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33965 PyObject *resultobj = 0;
33966 wxWindow *arg1 = (wxWindow *) 0 ;
33967 wxSize *arg2 = 0 ;
33968 wxSize result;
33969 void *argp1 = 0 ;
33970 int res1 = 0 ;
33971 wxSize temp2 ;
33972 PyObject * obj0 = 0 ;
33973 PyObject * obj1 = 0 ;
33974 char * kwnames[] = {
33975 (char *) "self",(char *) "sz", NULL
33976 };
33977
33978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33980 if (!SWIG_IsOK(res1)) {
33981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33982 }
33983 arg1 = reinterpret_cast< wxWindow * >(argp1);
33984 {
33985 arg2 = &temp2;
33986 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33987 }
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34002 PyObject *resultobj = 0;
34003 wxWindow *arg1 = (wxWindow *) 0 ;
34004 int arg2 ;
34005 int arg3 ;
34006 void *argp1 = 0 ;
34007 int res1 = 0 ;
34008 int val2 ;
34009 int ecode2 = 0 ;
34010 int val3 ;
34011 int ecode3 = 0 ;
34012 PyObject * obj0 = 0 ;
34013 PyObject * obj1 = 0 ;
34014 PyObject * obj2 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "x",(char *) "y", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34023 }
34024 arg1 = reinterpret_cast< wxWindow * >(argp1);
34025 ecode2 = SWIG_AsVal_int(obj1, &val2);
34026 if (!SWIG_IsOK(ecode2)) {
34027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34028 }
34029 arg2 = static_cast< int >(val2);
34030 ecode3 = SWIG_AsVal_int(obj2, &val3);
34031 if (!SWIG_IsOK(ecode3)) {
34032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34033 }
34034 arg3 = static_cast< int >(val3);
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 (arg1)->WarpPointer(arg2,arg3);
34038 wxPyEndAllowThreads(__tstate);
34039 if (PyErr_Occurred()) SWIG_fail;
34040 }
34041 resultobj = SWIG_Py_Void();
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34049 PyObject *resultobj = 0;
34050 wxWindow *arg1 = (wxWindow *) 0 ;
34051 void *argp1 = 0 ;
34052 int res1 = 0 ;
34053 PyObject *swig_obj[1] ;
34054
34055 if (!args) SWIG_fail;
34056 swig_obj[0] = args;
34057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34058 if (!SWIG_IsOK(res1)) {
34059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34060 }
34061 arg1 = reinterpret_cast< wxWindow * >(argp1);
34062 {
34063 PyThreadState* __tstate = wxPyBeginAllowThreads();
34064 (arg1)->CaptureMouse();
34065 wxPyEndAllowThreads(__tstate);
34066 if (PyErr_Occurred()) SWIG_fail;
34067 }
34068 resultobj = SWIG_Py_Void();
34069 return resultobj;
34070 fail:
34071 return NULL;
34072 }
34073
34074
34075 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34076 PyObject *resultobj = 0;
34077 wxWindow *arg1 = (wxWindow *) 0 ;
34078 void *argp1 = 0 ;
34079 int res1 = 0 ;
34080 PyObject *swig_obj[1] ;
34081
34082 if (!args) SWIG_fail;
34083 swig_obj[0] = args;
34084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34085 if (!SWIG_IsOK(res1)) {
34086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34087 }
34088 arg1 = reinterpret_cast< wxWindow * >(argp1);
34089 {
34090 PyThreadState* __tstate = wxPyBeginAllowThreads();
34091 (arg1)->ReleaseMouse();
34092 wxPyEndAllowThreads(__tstate);
34093 if (PyErr_Occurred()) SWIG_fail;
34094 }
34095 resultobj = SWIG_Py_Void();
34096 return resultobj;
34097 fail:
34098 return NULL;
34099 }
34100
34101
34102 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34103 PyObject *resultobj = 0;
34104 wxWindow *result = 0 ;
34105
34106 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34107 {
34108 if (!wxPyCheckForApp()) SWIG_fail;
34109 PyThreadState* __tstate = wxPyBeginAllowThreads();
34110 result = (wxWindow *)wxWindow::GetCapture();
34111 wxPyEndAllowThreads(__tstate);
34112 if (PyErr_Occurred()) SWIG_fail;
34113 }
34114 {
34115 resultobj = wxPyMake_wxObject(result, 0);
34116 }
34117 return resultobj;
34118 fail:
34119 return NULL;
34120 }
34121
34122
34123 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34124 PyObject *resultobj = 0;
34125 wxWindow *arg1 = (wxWindow *) 0 ;
34126 bool result;
34127 void *argp1 = 0 ;
34128 int res1 = 0 ;
34129 PyObject *swig_obj[1] ;
34130
34131 if (!args) SWIG_fail;
34132 swig_obj[0] = args;
34133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34134 if (!SWIG_IsOK(res1)) {
34135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34136 }
34137 arg1 = reinterpret_cast< wxWindow * >(argp1);
34138 {
34139 PyThreadState* __tstate = wxPyBeginAllowThreads();
34140 result = (bool)((wxWindow const *)arg1)->HasCapture();
34141 wxPyEndAllowThreads(__tstate);
34142 if (PyErr_Occurred()) SWIG_fail;
34143 }
34144 {
34145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34146 }
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj = 0;
34155 wxWindow *arg1 = (wxWindow *) 0 ;
34156 bool arg2 = (bool) true ;
34157 wxRect *arg3 = (wxRect *) NULL ;
34158 void *argp1 = 0 ;
34159 int res1 = 0 ;
34160 bool val2 ;
34161 int ecode2 = 0 ;
34162 void *argp3 = 0 ;
34163 int res3 = 0 ;
34164 PyObject * obj0 = 0 ;
34165 PyObject * obj1 = 0 ;
34166 PyObject * obj2 = 0 ;
34167 char * kwnames[] = {
34168 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34169 };
34170
34171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34173 if (!SWIG_IsOK(res1)) {
34174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34175 }
34176 arg1 = reinterpret_cast< wxWindow * >(argp1);
34177 if (obj1) {
34178 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34179 if (!SWIG_IsOK(ecode2)) {
34180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34181 }
34182 arg2 = static_cast< bool >(val2);
34183 }
34184 if (obj2) {
34185 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34186 if (!SWIG_IsOK(res3)) {
34187 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34188 }
34189 arg3 = reinterpret_cast< wxRect * >(argp3);
34190 }
34191 {
34192 PyThreadState* __tstate = wxPyBeginAllowThreads();
34193 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34194 wxPyEndAllowThreads(__tstate);
34195 if (PyErr_Occurred()) SWIG_fail;
34196 }
34197 resultobj = SWIG_Py_Void();
34198 return resultobj;
34199 fail:
34200 return NULL;
34201 }
34202
34203
34204 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34205 PyObject *resultobj = 0;
34206 wxWindow *arg1 = (wxWindow *) 0 ;
34207 wxRect *arg2 = 0 ;
34208 bool arg3 = (bool) true ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 wxRect temp2 ;
34212 bool val3 ;
34213 int ecode3 = 0 ;
34214 PyObject * obj0 = 0 ;
34215 PyObject * obj1 = 0 ;
34216 PyObject * obj2 = 0 ;
34217 char * kwnames[] = {
34218 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34219 };
34220
34221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34223 if (!SWIG_IsOK(res1)) {
34224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34225 }
34226 arg1 = reinterpret_cast< wxWindow * >(argp1);
34227 {
34228 arg2 = &temp2;
34229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34230 }
34231 if (obj2) {
34232 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34233 if (!SWIG_IsOK(ecode3)) {
34234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34235 }
34236 arg3 = static_cast< bool >(val3);
34237 }
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_Py_Void();
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *resultobj = 0;
34253 wxWindow *arg1 = (wxWindow *) 0 ;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 PyObject *swig_obj[1] ;
34257
34258 if (!args) SWIG_fail;
34259 swig_obj[0] = args;
34260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34261 if (!SWIG_IsOK(res1)) {
34262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34263 }
34264 arg1 = reinterpret_cast< wxWindow * >(argp1);
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 (arg1)->Update();
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 resultobj = SWIG_Py_Void();
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34279 PyObject *resultobj = 0;
34280 wxWindow *arg1 = (wxWindow *) 0 ;
34281 void *argp1 = 0 ;
34282 int res1 = 0 ;
34283 PyObject *swig_obj[1] ;
34284
34285 if (!args) SWIG_fail;
34286 swig_obj[0] = args;
34287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34288 if (!SWIG_IsOK(res1)) {
34289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34290 }
34291 arg1 = reinterpret_cast< wxWindow * >(argp1);
34292 {
34293 PyThreadState* __tstate = wxPyBeginAllowThreads();
34294 (arg1)->ClearBackground();
34295 wxPyEndAllowThreads(__tstate);
34296 if (PyErr_Occurred()) SWIG_fail;
34297 }
34298 resultobj = SWIG_Py_Void();
34299 return resultobj;
34300 fail:
34301 return NULL;
34302 }
34303
34304
34305 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34306 PyObject *resultobj = 0;
34307 wxWindow *arg1 = (wxWindow *) 0 ;
34308 void *argp1 = 0 ;
34309 int res1 = 0 ;
34310 PyObject *swig_obj[1] ;
34311
34312 if (!args) SWIG_fail;
34313 swig_obj[0] = args;
34314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34315 if (!SWIG_IsOK(res1)) {
34316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34317 }
34318 arg1 = reinterpret_cast< wxWindow * >(argp1);
34319 {
34320 PyThreadState* __tstate = wxPyBeginAllowThreads();
34321 (arg1)->Freeze();
34322 wxPyEndAllowThreads(__tstate);
34323 if (PyErr_Occurred()) SWIG_fail;
34324 }
34325 resultobj = SWIG_Py_Void();
34326 return resultobj;
34327 fail:
34328 return NULL;
34329 }
34330
34331
34332 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34333 PyObject *resultobj = 0;
34334 wxWindow *arg1 = (wxWindow *) 0 ;
34335 void *argp1 = 0 ;
34336 int res1 = 0 ;
34337 PyObject *swig_obj[1] ;
34338
34339 if (!args) SWIG_fail;
34340 swig_obj[0] = args;
34341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34342 if (!SWIG_IsOK(res1)) {
34343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34344 }
34345 arg1 = reinterpret_cast< wxWindow * >(argp1);
34346 {
34347 PyThreadState* __tstate = wxPyBeginAllowThreads();
34348 (arg1)->Thaw();
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 resultobj = SWIG_Py_Void();
34353 return resultobj;
34354 fail:
34355 return NULL;
34356 }
34357
34358
34359 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34360 PyObject *resultobj = 0;
34361 wxWindow *arg1 = (wxWindow *) 0 ;
34362 wxDC *arg2 = 0 ;
34363 void *argp1 = 0 ;
34364 int res1 = 0 ;
34365 void *argp2 = 0 ;
34366 int res2 = 0 ;
34367 PyObject * obj0 = 0 ;
34368 PyObject * obj1 = 0 ;
34369 char * kwnames[] = {
34370 (char *) "self",(char *) "dc", NULL
34371 };
34372
34373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34375 if (!SWIG_IsOK(res1)) {
34376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34377 }
34378 arg1 = reinterpret_cast< wxWindow * >(argp1);
34379 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34380 if (!SWIG_IsOK(res2)) {
34381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34382 }
34383 if (!argp2) {
34384 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34385 }
34386 arg2 = reinterpret_cast< wxDC * >(argp2);
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 (arg1)->PrepareDC(*arg2);
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 resultobj = SWIG_Py_Void();
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34401 PyObject *resultobj = 0;
34402 wxWindow *arg1 = (wxWindow *) 0 ;
34403 wxRegion *result = 0 ;
34404 void *argp1 = 0 ;
34405 int res1 = 0 ;
34406 PyObject *swig_obj[1] ;
34407
34408 if (!args) SWIG_fail;
34409 swig_obj[0] = args;
34410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34411 if (!SWIG_IsOK(res1)) {
34412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34413 }
34414 arg1 = reinterpret_cast< wxWindow * >(argp1);
34415 {
34416 PyThreadState* __tstate = wxPyBeginAllowThreads();
34417 {
34418 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34419 result = (wxRegion *) &_result_ref;
34420 }
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 wxRect result;
34435 void *argp1 = 0 ;
34436 int res1 = 0 ;
34437 PyObject *swig_obj[1] ;
34438
34439 if (!args) SWIG_fail;
34440 swig_obj[0] = args;
34441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34442 if (!SWIG_IsOK(res1)) {
34443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34444 }
34445 arg1 = reinterpret_cast< wxWindow * >(argp1);
34446 {
34447 PyThreadState* __tstate = wxPyBeginAllowThreads();
34448 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34449 wxPyEndAllowThreads(__tstate);
34450 if (PyErr_Occurred()) SWIG_fail;
34451 }
34452 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34453 return resultobj;
34454 fail:
34455 return NULL;
34456 }
34457
34458
34459 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34460 PyObject *resultobj = 0;
34461 wxWindow *arg1 = (wxWindow *) 0 ;
34462 int arg2 ;
34463 int arg3 ;
34464 int arg4 = (int) 1 ;
34465 int arg5 = (int) 1 ;
34466 bool result;
34467 void *argp1 = 0 ;
34468 int res1 = 0 ;
34469 int val2 ;
34470 int ecode2 = 0 ;
34471 int val3 ;
34472 int ecode3 = 0 ;
34473 int val4 ;
34474 int ecode4 = 0 ;
34475 int val5 ;
34476 int ecode5 = 0 ;
34477 PyObject * obj0 = 0 ;
34478 PyObject * obj1 = 0 ;
34479 PyObject * obj2 = 0 ;
34480 PyObject * obj3 = 0 ;
34481 PyObject * obj4 = 0 ;
34482 char * kwnames[] = {
34483 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34484 };
34485
34486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34488 if (!SWIG_IsOK(res1)) {
34489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34490 }
34491 arg1 = reinterpret_cast< wxWindow * >(argp1);
34492 ecode2 = SWIG_AsVal_int(obj1, &val2);
34493 if (!SWIG_IsOK(ecode2)) {
34494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34495 }
34496 arg2 = static_cast< int >(val2);
34497 ecode3 = SWIG_AsVal_int(obj2, &val3);
34498 if (!SWIG_IsOK(ecode3)) {
34499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34500 }
34501 arg3 = static_cast< int >(val3);
34502 if (obj3) {
34503 ecode4 = SWIG_AsVal_int(obj3, &val4);
34504 if (!SWIG_IsOK(ecode4)) {
34505 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34506 }
34507 arg4 = static_cast< int >(val4);
34508 }
34509 if (obj4) {
34510 ecode5 = SWIG_AsVal_int(obj4, &val5);
34511 if (!SWIG_IsOK(ecode5)) {
34512 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34513 }
34514 arg5 = static_cast< int >(val5);
34515 }
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34519 wxPyEndAllowThreads(__tstate);
34520 if (PyErr_Occurred()) SWIG_fail;
34521 }
34522 {
34523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34524 }
34525 return resultobj;
34526 fail:
34527 return NULL;
34528 }
34529
34530
34531 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34532 PyObject *resultobj = 0;
34533 wxWindow *arg1 = (wxWindow *) 0 ;
34534 wxPoint *arg2 = 0 ;
34535 bool result;
34536 void *argp1 = 0 ;
34537 int res1 = 0 ;
34538 wxPoint temp2 ;
34539 PyObject * obj0 = 0 ;
34540 PyObject * obj1 = 0 ;
34541 char * kwnames[] = {
34542 (char *) "self",(char *) "pt", NULL
34543 };
34544
34545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34547 if (!SWIG_IsOK(res1)) {
34548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34549 }
34550 arg1 = reinterpret_cast< wxWindow * >(argp1);
34551 {
34552 arg2 = &temp2;
34553 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34554 }
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34563 }
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34571 PyObject *resultobj = 0;
34572 wxWindow *arg1 = (wxWindow *) 0 ;
34573 wxRect *arg2 = 0 ;
34574 bool result;
34575 void *argp1 = 0 ;
34576 int res1 = 0 ;
34577 wxRect temp2 ;
34578 PyObject * obj0 = 0 ;
34579 PyObject * obj1 = 0 ;
34580 char * kwnames[] = {
34581 (char *) "self",(char *) "rect", NULL
34582 };
34583
34584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34586 if (!SWIG_IsOK(res1)) {
34587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34588 }
34589 arg1 = reinterpret_cast< wxWindow * >(argp1);
34590 {
34591 arg2 = &temp2;
34592 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34593 }
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34597 wxPyEndAllowThreads(__tstate);
34598 if (PyErr_Occurred()) SWIG_fail;
34599 }
34600 {
34601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34602 }
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 SwigValueWrapper<wxVisualAttributes > result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj = 0;
34639 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34640 SwigValueWrapper<wxVisualAttributes > result;
34641 int val1 ;
34642 int ecode1 = 0 ;
34643 PyObject * obj0 = 0 ;
34644 char * kwnames[] = {
34645 (char *) "variant", NULL
34646 };
34647
34648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34649 if (obj0) {
34650 ecode1 = SWIG_AsVal_int(obj0, &val1);
34651 if (!SWIG_IsOK(ecode1)) {
34652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34653 }
34654 arg1 = static_cast< wxWindowVariant >(val1);
34655 }
34656 {
34657 if (!wxPyCheckForApp()) SWIG_fail;
34658 PyThreadState* __tstate = wxPyBeginAllowThreads();
34659 result = wxWindow::GetClassDefaultAttributes(arg1);
34660 wxPyEndAllowThreads(__tstate);
34661 if (PyErr_Occurred()) SWIG_fail;
34662 }
34663 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34664 return resultobj;
34665 fail:
34666 return NULL;
34667 }
34668
34669
34670 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34671 PyObject *resultobj = 0;
34672 wxWindow *arg1 = (wxWindow *) 0 ;
34673 wxColour *arg2 = 0 ;
34674 bool result;
34675 void *argp1 = 0 ;
34676 int res1 = 0 ;
34677 wxColour temp2 ;
34678 PyObject * obj0 = 0 ;
34679 PyObject * obj1 = 0 ;
34680 char * kwnames[] = {
34681 (char *) "self",(char *) "colour", NULL
34682 };
34683
34684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34686 if (!SWIG_IsOK(res1)) {
34687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34688 }
34689 arg1 = reinterpret_cast< wxWindow * >(argp1);
34690 {
34691 arg2 = &temp2;
34692 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34693 }
34694 {
34695 PyThreadState* __tstate = wxPyBeginAllowThreads();
34696 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34697 wxPyEndAllowThreads(__tstate);
34698 if (PyErr_Occurred()) SWIG_fail;
34699 }
34700 {
34701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34702 }
34703 return resultobj;
34704 fail:
34705 return NULL;
34706 }
34707
34708
34709 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34710 PyObject *resultobj = 0;
34711 wxWindow *arg1 = (wxWindow *) 0 ;
34712 wxColour *arg2 = 0 ;
34713 void *argp1 = 0 ;
34714 int res1 = 0 ;
34715 wxColour temp2 ;
34716 PyObject * obj0 = 0 ;
34717 PyObject * obj1 = 0 ;
34718 char * kwnames[] = {
34719 (char *) "self",(char *) "colour", NULL
34720 };
34721
34722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34726 }
34727 arg1 = reinterpret_cast< wxWindow * >(argp1);
34728 {
34729 arg2 = &temp2;
34730 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34731 }
34732 {
34733 PyThreadState* __tstate = wxPyBeginAllowThreads();
34734 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34735 wxPyEndAllowThreads(__tstate);
34736 if (PyErr_Occurred()) SWIG_fail;
34737 }
34738 resultobj = SWIG_Py_Void();
34739 return resultobj;
34740 fail:
34741 return NULL;
34742 }
34743
34744
34745 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34746 PyObject *resultobj = 0;
34747 wxWindow *arg1 = (wxWindow *) 0 ;
34748 wxColour *arg2 = 0 ;
34749 bool result;
34750 void *argp1 = 0 ;
34751 int res1 = 0 ;
34752 wxColour temp2 ;
34753 PyObject * obj0 = 0 ;
34754 PyObject * obj1 = 0 ;
34755 char * kwnames[] = {
34756 (char *) "self",(char *) "colour", NULL
34757 };
34758
34759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34761 if (!SWIG_IsOK(res1)) {
34762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34763 }
34764 arg1 = reinterpret_cast< wxWindow * >(argp1);
34765 {
34766 arg2 = &temp2;
34767 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34768 }
34769 {
34770 PyThreadState* __tstate = wxPyBeginAllowThreads();
34771 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34772 wxPyEndAllowThreads(__tstate);
34773 if (PyErr_Occurred()) SWIG_fail;
34774 }
34775 {
34776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34777 }
34778 return resultobj;
34779 fail:
34780 return NULL;
34781 }
34782
34783
34784 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34785 PyObject *resultobj = 0;
34786 wxWindow *arg1 = (wxWindow *) 0 ;
34787 wxColour *arg2 = 0 ;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 wxColour temp2 ;
34791 PyObject * obj0 = 0 ;
34792 PyObject * obj1 = 0 ;
34793 char * kwnames[] = {
34794 (char *) "self",(char *) "colour", NULL
34795 };
34796
34797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34799 if (!SWIG_IsOK(res1)) {
34800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34801 }
34802 arg1 = reinterpret_cast< wxWindow * >(argp1);
34803 {
34804 arg2 = &temp2;
34805 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34806 }
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 resultobj = SWIG_Py_Void();
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34821 PyObject *resultobj = 0;
34822 wxWindow *arg1 = (wxWindow *) 0 ;
34823 wxColour 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_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34833 }
34834 arg1 = reinterpret_cast< wxWindow * >(argp1);
34835 {
34836 PyThreadState* __tstate = wxPyBeginAllowThreads();
34837 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34838 wxPyEndAllowThreads(__tstate);
34839 if (PyErr_Occurred()) SWIG_fail;
34840 }
34841 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34849 PyObject *resultobj = 0;
34850 wxWindow *arg1 = (wxWindow *) 0 ;
34851 wxColour result;
34852 void *argp1 = 0 ;
34853 int res1 = 0 ;
34854 PyObject *swig_obj[1] ;
34855
34856 if (!args) SWIG_fail;
34857 swig_obj[0] = args;
34858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 result = ((wxWindow const *)arg1)->GetForegroundColour();
34866 wxPyEndAllowThreads(__tstate);
34867 if (PyErr_Occurred()) SWIG_fail;
34868 }
34869 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34870 return resultobj;
34871 fail:
34872 return NULL;
34873 }
34874
34875
34876 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34877 PyObject *resultobj = 0;
34878 wxWindow *arg1 = (wxWindow *) 0 ;
34879 bool result;
34880 void *argp1 = 0 ;
34881 int res1 = 0 ;
34882 PyObject *swig_obj[1] ;
34883
34884 if (!args) SWIG_fail;
34885 swig_obj[0] = args;
34886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34887 if (!SWIG_IsOK(res1)) {
34888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34889 }
34890 arg1 = reinterpret_cast< wxWindow * >(argp1);
34891 {
34892 PyThreadState* __tstate = wxPyBeginAllowThreads();
34893 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34894 wxPyEndAllowThreads(__tstate);
34895 if (PyErr_Occurred()) SWIG_fail;
34896 }
34897 {
34898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34899 }
34900 return resultobj;
34901 fail:
34902 return NULL;
34903 }
34904
34905
34906 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34907 PyObject *resultobj = 0;
34908 wxWindow *arg1 = (wxWindow *) 0 ;
34909 bool result;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 PyObject *swig_obj[1] ;
34913
34914 if (!args) SWIG_fail;
34915 swig_obj[0] = args;
34916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34917 if (!SWIG_IsOK(res1)) {
34918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34919 }
34920 arg1 = reinterpret_cast< wxWindow * >(argp1);
34921 {
34922 PyThreadState* __tstate = wxPyBeginAllowThreads();
34923 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 {
34928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34929 }
34930 return resultobj;
34931 fail:
34932 return NULL;
34933 }
34934
34935
34936 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj = 0;
34938 wxWindow *arg1 = (wxWindow *) 0 ;
34939 wxBackgroundStyle arg2 ;
34940 bool result;
34941 void *argp1 = 0 ;
34942 int res1 = 0 ;
34943 int val2 ;
34944 int ecode2 = 0 ;
34945 PyObject * obj0 = 0 ;
34946 PyObject * obj1 = 0 ;
34947 char * kwnames[] = {
34948 (char *) "self",(char *) "style", NULL
34949 };
34950
34951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34953 if (!SWIG_IsOK(res1)) {
34954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34955 }
34956 arg1 = reinterpret_cast< wxWindow * >(argp1);
34957 ecode2 = SWIG_AsVal_int(obj1, &val2);
34958 if (!SWIG_IsOK(ecode2)) {
34959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34960 }
34961 arg2 = static_cast< wxBackgroundStyle >(val2);
34962 {
34963 PyThreadState* __tstate = wxPyBeginAllowThreads();
34964 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34965 wxPyEndAllowThreads(__tstate);
34966 if (PyErr_Occurred()) SWIG_fail;
34967 }
34968 {
34969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34970 }
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 wxBackgroundStyle result;
34981 void *argp1 = 0 ;
34982 int res1 = 0 ;
34983 PyObject *swig_obj[1] ;
34984
34985 if (!args) SWIG_fail;
34986 swig_obj[0] = args;
34987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34988 if (!SWIG_IsOK(res1)) {
34989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34990 }
34991 arg1 = reinterpret_cast< wxWindow * >(argp1);
34992 {
34993 PyThreadState* __tstate = wxPyBeginAllowThreads();
34994 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34995 wxPyEndAllowThreads(__tstate);
34996 if (PyErr_Occurred()) SWIG_fail;
34997 }
34998 resultobj = SWIG_From_int(static_cast< int >(result));
34999 return resultobj;
35000 fail:
35001 return NULL;
35002 }
35003
35004
35005 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35006 PyObject *resultobj = 0;
35007 wxWindow *arg1 = (wxWindow *) 0 ;
35008 bool result;
35009 void *argp1 = 0 ;
35010 int res1 = 0 ;
35011 PyObject *swig_obj[1] ;
35012
35013 if (!args) SWIG_fail;
35014 swig_obj[0] = args;
35015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35016 if (!SWIG_IsOK(res1)) {
35017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35018 }
35019 arg1 = reinterpret_cast< wxWindow * >(argp1);
35020 {
35021 PyThreadState* __tstate = wxPyBeginAllowThreads();
35022 result = (bool)(arg1)->HasTransparentBackground();
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_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35036 PyObject *resultobj = 0;
35037 wxWindow *arg1 = (wxWindow *) 0 ;
35038 wxCursor *arg2 = 0 ;
35039 bool result;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 void *argp2 = 0 ;
35043 int res2 = 0 ;
35044 PyObject * obj0 = 0 ;
35045 PyObject * obj1 = 0 ;
35046 char * kwnames[] = {
35047 (char *) "self",(char *) "cursor", NULL
35048 };
35049
35050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",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_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35054 }
35055 arg1 = reinterpret_cast< wxWindow * >(argp1);
35056 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35057 if (!SWIG_IsOK(res2)) {
35058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35059 }
35060 if (!argp2) {
35061 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35062 }
35063 arg2 = reinterpret_cast< wxCursor * >(argp2);
35064 {
35065 PyThreadState* __tstate = wxPyBeginAllowThreads();
35066 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35067 wxPyEndAllowThreads(__tstate);
35068 if (PyErr_Occurred()) SWIG_fail;
35069 }
35070 {
35071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35072 }
35073 return resultobj;
35074 fail:
35075 return NULL;
35076 }
35077
35078
35079 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35080 PyObject *resultobj = 0;
35081 wxWindow *arg1 = (wxWindow *) 0 ;
35082 wxCursor result;
35083 void *argp1 = 0 ;
35084 int res1 = 0 ;
35085 PyObject *swig_obj[1] ;
35086
35087 if (!args) SWIG_fail;
35088 swig_obj[0] = args;
35089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35090 if (!SWIG_IsOK(res1)) {
35091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35092 }
35093 arg1 = reinterpret_cast< wxWindow * >(argp1);
35094 {
35095 PyThreadState* __tstate = wxPyBeginAllowThreads();
35096 result = (arg1)->GetCursor();
35097 wxPyEndAllowThreads(__tstate);
35098 if (PyErr_Occurred()) SWIG_fail;
35099 }
35100 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35101 return resultobj;
35102 fail:
35103 return NULL;
35104 }
35105
35106
35107 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35108 PyObject *resultobj = 0;
35109 wxWindow *arg1 = (wxWindow *) 0 ;
35110 wxFont *arg2 = 0 ;
35111 bool result;
35112 void *argp1 = 0 ;
35113 int res1 = 0 ;
35114 void *argp2 = 0 ;
35115 int res2 = 0 ;
35116 PyObject * obj0 = 0 ;
35117 PyObject * obj1 = 0 ;
35118 char * kwnames[] = {
35119 (char *) "self",(char *) "font", NULL
35120 };
35121
35122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35124 if (!SWIG_IsOK(res1)) {
35125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35126 }
35127 arg1 = reinterpret_cast< wxWindow * >(argp1);
35128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35129 if (!SWIG_IsOK(res2)) {
35130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35131 }
35132 if (!argp2) {
35133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35134 }
35135 arg2 = reinterpret_cast< wxFont * >(argp2);
35136 {
35137 PyThreadState* __tstate = wxPyBeginAllowThreads();
35138 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 {
35143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35144 }
35145 return resultobj;
35146 fail:
35147 return NULL;
35148 }
35149
35150
35151 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35152 PyObject *resultobj = 0;
35153 wxWindow *arg1 = (wxWindow *) 0 ;
35154 wxFont *arg2 = 0 ;
35155 void *argp1 = 0 ;
35156 int res1 = 0 ;
35157 void *argp2 = 0 ;
35158 int res2 = 0 ;
35159 PyObject * obj0 = 0 ;
35160 PyObject * obj1 = 0 ;
35161 char * kwnames[] = {
35162 (char *) "self",(char *) "font", NULL
35163 };
35164
35165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35167 if (!SWIG_IsOK(res1)) {
35168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35169 }
35170 arg1 = reinterpret_cast< wxWindow * >(argp1);
35171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35172 if (!SWIG_IsOK(res2)) {
35173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35174 }
35175 if (!argp2) {
35176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35177 }
35178 arg2 = reinterpret_cast< wxFont * >(argp2);
35179 {
35180 PyThreadState* __tstate = wxPyBeginAllowThreads();
35181 (arg1)->SetOwnFont((wxFont const &)*arg2);
35182 wxPyEndAllowThreads(__tstate);
35183 if (PyErr_Occurred()) SWIG_fail;
35184 }
35185 resultobj = SWIG_Py_Void();
35186 return resultobj;
35187 fail:
35188 return NULL;
35189 }
35190
35191
35192 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35193 PyObject *resultobj = 0;
35194 wxWindow *arg1 = (wxWindow *) 0 ;
35195 wxFont result;
35196 void *argp1 = 0 ;
35197 int res1 = 0 ;
35198 PyObject *swig_obj[1] ;
35199
35200 if (!args) SWIG_fail;
35201 swig_obj[0] = args;
35202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35203 if (!SWIG_IsOK(res1)) {
35204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35205 }
35206 arg1 = reinterpret_cast< wxWindow * >(argp1);
35207 {
35208 PyThreadState* __tstate = wxPyBeginAllowThreads();
35209 result = (arg1)->GetFont();
35210 wxPyEndAllowThreads(__tstate);
35211 if (PyErr_Occurred()) SWIG_fail;
35212 }
35213 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35214 return resultobj;
35215 fail:
35216 return NULL;
35217 }
35218
35219
35220 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35221 PyObject *resultobj = 0;
35222 wxWindow *arg1 = (wxWindow *) 0 ;
35223 wxCaret *arg2 = (wxCaret *) 0 ;
35224 void *argp1 = 0 ;
35225 int res1 = 0 ;
35226 int res2 = 0 ;
35227 PyObject * obj0 = 0 ;
35228 PyObject * obj1 = 0 ;
35229 char * kwnames[] = {
35230 (char *) "self",(char *) "caret", NULL
35231 };
35232
35233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35235 if (!SWIG_IsOK(res1)) {
35236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35237 }
35238 arg1 = reinterpret_cast< wxWindow * >(argp1);
35239 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35240 if (!SWIG_IsOK(res2)) {
35241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35242 }
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 (arg1)->SetCaret(arg2);
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 resultobj = SWIG_Py_Void();
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35257 PyObject *resultobj = 0;
35258 wxWindow *arg1 = (wxWindow *) 0 ;
35259 wxCaret *result = 0 ;
35260 void *argp1 = 0 ;
35261 int res1 = 0 ;
35262 PyObject *swig_obj[1] ;
35263
35264 if (!args) SWIG_fail;
35265 swig_obj[0] = args;
35266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35267 if (!SWIG_IsOK(res1)) {
35268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35269 }
35270 arg1 = reinterpret_cast< wxWindow * >(argp1);
35271 {
35272 PyThreadState* __tstate = wxPyBeginAllowThreads();
35273 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35274 wxPyEndAllowThreads(__tstate);
35275 if (PyErr_Occurred()) SWIG_fail;
35276 }
35277 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35278 return resultobj;
35279 fail:
35280 return NULL;
35281 }
35282
35283
35284 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35285 PyObject *resultobj = 0;
35286 wxWindow *arg1 = (wxWindow *) 0 ;
35287 int result;
35288 void *argp1 = 0 ;
35289 int res1 = 0 ;
35290 PyObject *swig_obj[1] ;
35291
35292 if (!args) SWIG_fail;
35293 swig_obj[0] = args;
35294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35295 if (!SWIG_IsOK(res1)) {
35296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35297 }
35298 arg1 = reinterpret_cast< wxWindow * >(argp1);
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_From_int(static_cast< int >(result));
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxWindow *arg1 = (wxWindow *) 0 ;
35315 int result;
35316 void *argp1 = 0 ;
35317 int res1 = 0 ;
35318 PyObject *swig_obj[1] ;
35319
35320 if (!args) SWIG_fail;
35321 swig_obj[0] = args;
35322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35325 }
35326 arg1 = reinterpret_cast< wxWindow * >(argp1);
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_From_int(static_cast< int >(result));
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 wxString *arg2 = 0 ;
35344 int *arg3 = (int *) 0 ;
35345 int *arg4 = (int *) 0 ;
35346 void *argp1 = 0 ;
35347 int res1 = 0 ;
35348 bool temp2 = false ;
35349 int temp3 ;
35350 int res3 = SWIG_TMPOBJ ;
35351 int temp4 ;
35352 int res4 = SWIG_TMPOBJ ;
35353 PyObject * obj0 = 0 ;
35354 PyObject * obj1 = 0 ;
35355 char * kwnames[] = {
35356 (char *) "self",(char *) "string", NULL
35357 };
35358
35359 arg3 = &temp3;
35360 arg4 = &temp4;
35361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35363 if (!SWIG_IsOK(res1)) {
35364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35365 }
35366 arg1 = reinterpret_cast< wxWindow * >(argp1);
35367 {
35368 arg2 = wxString_in_helper(obj1);
35369 if (arg2 == NULL) SWIG_fail;
35370 temp2 = true;
35371 }
35372 {
35373 PyThreadState* __tstate = wxPyBeginAllowThreads();
35374 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35375 wxPyEndAllowThreads(__tstate);
35376 if (PyErr_Occurred()) SWIG_fail;
35377 }
35378 resultobj = SWIG_Py_Void();
35379 if (SWIG_IsTmpObj(res3)) {
35380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35381 } else {
35382 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35384 }
35385 if (SWIG_IsTmpObj(res4)) {
35386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35387 } else {
35388 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35390 }
35391 {
35392 if (temp2)
35393 delete arg2;
35394 }
35395 return resultobj;
35396 fail:
35397 {
35398 if (temp2)
35399 delete arg2;
35400 }
35401 return NULL;
35402 }
35403
35404
35405 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35406 PyObject *resultobj = 0;
35407 wxWindow *arg1 = (wxWindow *) 0 ;
35408 wxString *arg2 = 0 ;
35409 int *arg3 = (int *) 0 ;
35410 int *arg4 = (int *) 0 ;
35411 int *arg5 = (int *) 0 ;
35412 int *arg6 = (int *) 0 ;
35413 wxFont *arg7 = (wxFont *) NULL ;
35414 void *argp1 = 0 ;
35415 int res1 = 0 ;
35416 bool temp2 = false ;
35417 int temp3 ;
35418 int res3 = SWIG_TMPOBJ ;
35419 int temp4 ;
35420 int res4 = SWIG_TMPOBJ ;
35421 int temp5 ;
35422 int res5 = SWIG_TMPOBJ ;
35423 int temp6 ;
35424 int res6 = SWIG_TMPOBJ ;
35425 void *argp7 = 0 ;
35426 int res7 = 0 ;
35427 PyObject * obj0 = 0 ;
35428 PyObject * obj1 = 0 ;
35429 PyObject * obj2 = 0 ;
35430 char * kwnames[] = {
35431 (char *) "self",(char *) "string",(char *) "font", NULL
35432 };
35433
35434 arg3 = &temp3;
35435 arg4 = &temp4;
35436 arg5 = &temp5;
35437 arg6 = &temp6;
35438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35440 if (!SWIG_IsOK(res1)) {
35441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35442 }
35443 arg1 = reinterpret_cast< wxWindow * >(argp1);
35444 {
35445 arg2 = wxString_in_helper(obj1);
35446 if (arg2 == NULL) SWIG_fail;
35447 temp2 = true;
35448 }
35449 if (obj2) {
35450 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35451 if (!SWIG_IsOK(res7)) {
35452 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35453 }
35454 arg7 = reinterpret_cast< wxFont * >(argp7);
35455 }
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 resultobj = SWIG_Py_Void();
35463 if (SWIG_IsTmpObj(res3)) {
35464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35465 } else {
35466 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35468 }
35469 if (SWIG_IsTmpObj(res4)) {
35470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35471 } else {
35472 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35474 }
35475 if (SWIG_IsTmpObj(res5)) {
35476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35477 } else {
35478 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35480 }
35481 if (SWIG_IsTmpObj(res6)) {
35482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35483 } else {
35484 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35486 }
35487 {
35488 if (temp2)
35489 delete arg2;
35490 }
35491 return resultobj;
35492 fail:
35493 {
35494 if (temp2)
35495 delete arg2;
35496 }
35497 return NULL;
35498 }
35499
35500
35501 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35502 PyObject *resultobj = 0;
35503 wxWindow *arg1 = (wxWindow *) 0 ;
35504 int *arg2 = (int *) 0 ;
35505 int *arg3 = (int *) 0 ;
35506 void *argp1 = 0 ;
35507 int res1 = 0 ;
35508 int temp2 ;
35509 int res2 = 0 ;
35510 int temp3 ;
35511 int res3 = 0 ;
35512 PyObject * obj0 = 0 ;
35513 PyObject * obj1 = 0 ;
35514 PyObject * obj2 = 0 ;
35515 char * kwnames[] = {
35516 (char *) "self",(char *) "x",(char *) "y", NULL
35517 };
35518
35519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35521 if (!SWIG_IsOK(res1)) {
35522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35523 }
35524 arg1 = reinterpret_cast< wxWindow * >(argp1);
35525 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35526 int val;
35527 int ecode = SWIG_AsVal_int(obj1, &val);
35528 if (!SWIG_IsOK(ecode)) {
35529 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35530 }
35531 temp2 = static_cast< int >(val);
35532 arg2 = &temp2;
35533 res2 = SWIG_AddTmpMask(ecode);
35534 }
35535 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35536 int val;
35537 int ecode = SWIG_AsVal_int(obj2, &val);
35538 if (!SWIG_IsOK(ecode)) {
35539 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35540 }
35541 temp3 = static_cast< int >(val);
35542 arg3 = &temp3;
35543 res3 = SWIG_AddTmpMask(ecode);
35544 }
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 resultobj = SWIG_Py_Void();
35552 if (SWIG_IsTmpObj(res2)) {
35553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35554 } else {
35555 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35556 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35557 }
35558 if (SWIG_IsTmpObj(res3)) {
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35560 } else {
35561 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35563 }
35564 return resultobj;
35565 fail:
35566 return NULL;
35567 }
35568
35569
35570 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35571 PyObject *resultobj = 0;
35572 wxWindow *arg1 = (wxWindow *) 0 ;
35573 int *arg2 = (int *) 0 ;
35574 int *arg3 = (int *) 0 ;
35575 void *argp1 = 0 ;
35576 int res1 = 0 ;
35577 int temp2 ;
35578 int res2 = 0 ;
35579 int temp3 ;
35580 int res3 = 0 ;
35581 PyObject * obj0 = 0 ;
35582 PyObject * obj1 = 0 ;
35583 PyObject * obj2 = 0 ;
35584 char * kwnames[] = {
35585 (char *) "self",(char *) "x",(char *) "y", NULL
35586 };
35587
35588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35590 if (!SWIG_IsOK(res1)) {
35591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35592 }
35593 arg1 = reinterpret_cast< wxWindow * >(argp1);
35594 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35595 int val;
35596 int ecode = SWIG_AsVal_int(obj1, &val);
35597 if (!SWIG_IsOK(ecode)) {
35598 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35599 }
35600 temp2 = static_cast< int >(val);
35601 arg2 = &temp2;
35602 res2 = SWIG_AddTmpMask(ecode);
35603 }
35604 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35605 int val;
35606 int ecode = SWIG_AsVal_int(obj2, &val);
35607 if (!SWIG_IsOK(ecode)) {
35608 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35609 }
35610 temp3 = static_cast< int >(val);
35611 arg3 = &temp3;
35612 res3 = SWIG_AddTmpMask(ecode);
35613 }
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 resultobj = SWIG_Py_Void();
35621 if (SWIG_IsTmpObj(res2)) {
35622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35623 } else {
35624 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35625 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35626 }
35627 if (SWIG_IsTmpObj(res3)) {
35628 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35629 } else {
35630 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35631 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35632 }
35633 return resultobj;
35634 fail:
35635 return NULL;
35636 }
35637
35638
35639 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35640 PyObject *resultobj = 0;
35641 wxWindow *arg1 = (wxWindow *) 0 ;
35642 wxPoint *arg2 = 0 ;
35643 wxPoint result;
35644 void *argp1 = 0 ;
35645 int res1 = 0 ;
35646 wxPoint temp2 ;
35647 PyObject * obj0 = 0 ;
35648 PyObject * obj1 = 0 ;
35649 char * kwnames[] = {
35650 (char *) "self",(char *) "pt", NULL
35651 };
35652
35653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 {
35660 arg2 = &temp2;
35661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35662 }
35663 {
35664 PyThreadState* __tstate = wxPyBeginAllowThreads();
35665 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35666 wxPyEndAllowThreads(__tstate);
35667 if (PyErr_Occurred()) SWIG_fail;
35668 }
35669 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35670 return resultobj;
35671 fail:
35672 return NULL;
35673 }
35674
35675
35676 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35677 PyObject *resultobj = 0;
35678 wxWindow *arg1 = (wxWindow *) 0 ;
35679 wxPoint *arg2 = 0 ;
35680 wxPoint result;
35681 void *argp1 = 0 ;
35682 int res1 = 0 ;
35683 wxPoint temp2 ;
35684 PyObject * obj0 = 0 ;
35685 PyObject * obj1 = 0 ;
35686 char * kwnames[] = {
35687 (char *) "self",(char *) "pt", NULL
35688 };
35689
35690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35694 }
35695 arg1 = reinterpret_cast< wxWindow * >(argp1);
35696 {
35697 arg2 = &temp2;
35698 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35699 }
35700 {
35701 PyThreadState* __tstate = wxPyBeginAllowThreads();
35702 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35703 wxPyEndAllowThreads(__tstate);
35704 if (PyErr_Occurred()) SWIG_fail;
35705 }
35706 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35707 return resultobj;
35708 fail:
35709 return NULL;
35710 }
35711
35712
35713 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35714 PyObject *resultobj = 0;
35715 wxWindow *arg1 = (wxWindow *) 0 ;
35716 int arg2 ;
35717 int arg3 ;
35718 wxHitTest result;
35719 void *argp1 = 0 ;
35720 int res1 = 0 ;
35721 int val2 ;
35722 int ecode2 = 0 ;
35723 int val3 ;
35724 int ecode3 = 0 ;
35725 PyObject * obj0 = 0 ;
35726 PyObject * obj1 = 0 ;
35727 PyObject * obj2 = 0 ;
35728 char * kwnames[] = {
35729 (char *) "self",(char *) "x",(char *) "y", NULL
35730 };
35731
35732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35736 }
35737 arg1 = reinterpret_cast< wxWindow * >(argp1);
35738 ecode2 = SWIG_AsVal_int(obj1, &val2);
35739 if (!SWIG_IsOK(ecode2)) {
35740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35741 }
35742 arg2 = static_cast< int >(val2);
35743 ecode3 = SWIG_AsVal_int(obj2, &val3);
35744 if (!SWIG_IsOK(ecode3)) {
35745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35746 }
35747 arg3 = static_cast< int >(val3);
35748 {
35749 PyThreadState* __tstate = wxPyBeginAllowThreads();
35750 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35751 wxPyEndAllowThreads(__tstate);
35752 if (PyErr_Occurred()) SWIG_fail;
35753 }
35754 resultobj = SWIG_From_int(static_cast< int >(result));
35755 return resultobj;
35756 fail:
35757 return NULL;
35758 }
35759
35760
35761 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35762 PyObject *resultobj = 0;
35763 wxWindow *arg1 = (wxWindow *) 0 ;
35764 wxPoint *arg2 = 0 ;
35765 wxHitTest result;
35766 void *argp1 = 0 ;
35767 int res1 = 0 ;
35768 wxPoint temp2 ;
35769 PyObject * obj0 = 0 ;
35770 PyObject * obj1 = 0 ;
35771 char * kwnames[] = {
35772 (char *) "self",(char *) "pt", NULL
35773 };
35774
35775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35777 if (!SWIG_IsOK(res1)) {
35778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35779 }
35780 arg1 = reinterpret_cast< wxWindow * >(argp1);
35781 {
35782 arg2 = &temp2;
35783 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35784 }
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 resultobj = SWIG_From_int(static_cast< int >(result));
35792 return resultobj;
35793 fail:
35794 return NULL;
35795 }
35796
35797
35798 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35799 PyObject *resultobj = 0;
35800 wxWindow *arg1 = (wxWindow *) 0 ;
35801 long arg2 ;
35802 wxBorder result;
35803 void *argp1 = 0 ;
35804 int res1 = 0 ;
35805 long val2 ;
35806 int ecode2 = 0 ;
35807
35808 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35810 if (!SWIG_IsOK(res1)) {
35811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35812 }
35813 arg1 = reinterpret_cast< wxWindow * >(argp1);
35814 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35815 if (!SWIG_IsOK(ecode2)) {
35816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35817 }
35818 arg2 = static_cast< long >(val2);
35819 {
35820 PyThreadState* __tstate = wxPyBeginAllowThreads();
35821 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 resultobj = SWIG_From_int(static_cast< int >(result));
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35833 PyObject *resultobj = 0;
35834 wxWindow *arg1 = (wxWindow *) 0 ;
35835 wxBorder result;
35836 void *argp1 = 0 ;
35837 int res1 = 0 ;
35838
35839 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 resultobj = SWIG_From_int(static_cast< int >(result));
35852 return resultobj;
35853 fail:
35854 return NULL;
35855 }
35856
35857
35858 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35859 int argc;
35860 PyObject *argv[3];
35861
35862 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35863 --argc;
35864 if (argc == 1) {
35865 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35866 }
35867 if (argc == 2) {
35868 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35869 }
35870
35871 fail:
35872 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35873 return NULL;
35874 }
35875
35876
35877 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = 0;
35879 wxWindow *arg1 = (wxWindow *) 0 ;
35880 long arg2 = (long) wxUPDATE_UI_NONE ;
35881 void *argp1 = 0 ;
35882 int res1 = 0 ;
35883 long val2 ;
35884 int ecode2 = 0 ;
35885 PyObject * obj0 = 0 ;
35886 PyObject * obj1 = 0 ;
35887 char * kwnames[] = {
35888 (char *) "self",(char *) "flags", NULL
35889 };
35890
35891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35893 if (!SWIG_IsOK(res1)) {
35894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35895 }
35896 arg1 = reinterpret_cast< wxWindow * >(argp1);
35897 if (obj1) {
35898 ecode2 = SWIG_AsVal_long(obj1, &val2);
35899 if (!SWIG_IsOK(ecode2)) {
35900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35901 }
35902 arg2 = static_cast< long >(val2);
35903 }
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 (arg1)->UpdateWindowUI(arg2);
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 resultobj = SWIG_Py_Void();
35911 return resultobj;
35912 fail:
35913 return NULL;
35914 }
35915
35916
35917 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35918 PyObject *resultobj = 0;
35919 wxWindow *arg1 = (wxWindow *) 0 ;
35920 wxMenu *arg2 = (wxMenu *) 0 ;
35921 int arg3 = (int) -1 ;
35922 int arg4 = (int) -1 ;
35923 bool result;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 void *argp2 = 0 ;
35927 int res2 = 0 ;
35928 int val3 ;
35929 int ecode3 = 0 ;
35930 int val4 ;
35931 int ecode4 = 0 ;
35932 PyObject * obj0 = 0 ;
35933 PyObject * obj1 = 0 ;
35934 PyObject * obj2 = 0 ;
35935 PyObject * obj3 = 0 ;
35936 char * kwnames[] = {
35937 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35938 };
35939
35940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35942 if (!SWIG_IsOK(res1)) {
35943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35944 }
35945 arg1 = reinterpret_cast< wxWindow * >(argp1);
35946 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35947 if (!SWIG_IsOK(res2)) {
35948 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35949 }
35950 arg2 = reinterpret_cast< wxMenu * >(argp2);
35951 if (obj2) {
35952 ecode3 = SWIG_AsVal_int(obj2, &val3);
35953 if (!SWIG_IsOK(ecode3)) {
35954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35955 }
35956 arg3 = static_cast< int >(val3);
35957 }
35958 if (obj3) {
35959 ecode4 = SWIG_AsVal_int(obj3, &val4);
35960 if (!SWIG_IsOK(ecode4)) {
35961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35962 }
35963 arg4 = static_cast< int >(val4);
35964 }
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 {
35972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35973 }
35974 return resultobj;
35975 fail:
35976 return NULL;
35977 }
35978
35979
35980 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35981 PyObject *resultobj = 0;
35982 wxWindow *arg1 = (wxWindow *) 0 ;
35983 wxMenu *arg2 = (wxMenu *) 0 ;
35984 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35985 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35986 bool result;
35987 void *argp1 = 0 ;
35988 int res1 = 0 ;
35989 void *argp2 = 0 ;
35990 int res2 = 0 ;
35991 wxPoint temp3 ;
35992 PyObject * obj0 = 0 ;
35993 PyObject * obj1 = 0 ;
35994 PyObject * obj2 = 0 ;
35995 char * kwnames[] = {
35996 (char *) "self",(char *) "menu",(char *) "pos", NULL
35997 };
35998
35999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36001 if (!SWIG_IsOK(res1)) {
36002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36003 }
36004 arg1 = reinterpret_cast< wxWindow * >(argp1);
36005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36006 if (!SWIG_IsOK(res2)) {
36007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36008 }
36009 arg2 = reinterpret_cast< wxMenu * >(argp2);
36010 if (obj2) {
36011 {
36012 arg3 = &temp3;
36013 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36014 }
36015 }
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 {
36023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36024 }
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 long result;
36035 void *argp1 = 0 ;
36036 int res1 = 0 ;
36037 PyObject *swig_obj[1] ;
36038
36039 if (!args) SWIG_fail;
36040 swig_obj[0] = args;
36041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36042 if (!SWIG_IsOK(res1)) {
36043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36044 }
36045 arg1 = reinterpret_cast< wxWindow * >(argp1);
36046 {
36047 PyThreadState* __tstate = wxPyBeginAllowThreads();
36048 result = (long)wxWindow_GetHandle(arg1);
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 resultobj = SWIG_From_long(static_cast< long >(result));
36053 return resultobj;
36054 fail:
36055 return NULL;
36056 }
36057
36058
36059 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36060 PyObject *resultobj = 0;
36061 wxWindow *arg1 = (wxWindow *) 0 ;
36062 long arg2 ;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 long val2 ;
36066 int ecode2 = 0 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 char * kwnames[] = {
36070 (char *) "self",(char *) "handle", NULL
36071 };
36072
36073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36075 if (!SWIG_IsOK(res1)) {
36076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36077 }
36078 arg1 = reinterpret_cast< wxWindow * >(argp1);
36079 ecode2 = SWIG_AsVal_long(obj1, &val2);
36080 if (!SWIG_IsOK(ecode2)) {
36081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36082 }
36083 arg2 = static_cast< long >(val2);
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 wxWindow_AssociateHandle(arg1,arg2);
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 resultobj = SWIG_Py_Void();
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 void *argp1 = 0 ;
36101 int res1 = 0 ;
36102 PyObject *swig_obj[1] ;
36103
36104 if (!args) SWIG_fail;
36105 swig_obj[0] = args;
36106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36107 if (!SWIG_IsOK(res1)) {
36108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36109 }
36110 arg1 = reinterpret_cast< wxWindow * >(argp1);
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 (arg1)->DissociateHandle();
36114 wxPyEndAllowThreads(__tstate);
36115 if (PyErr_Occurred()) SWIG_fail;
36116 }
36117 resultobj = SWIG_Py_Void();
36118 return resultobj;
36119 fail:
36120 return NULL;
36121 }
36122
36123
36124 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36125 PyObject *resultobj = 0;
36126 wxWindow *arg1 = (wxWindow *) 0 ;
36127 int arg2 ;
36128 bool result;
36129 void *argp1 = 0 ;
36130 int res1 = 0 ;
36131 int val2 ;
36132 int ecode2 = 0 ;
36133 PyObject * obj0 = 0 ;
36134 PyObject * obj1 = 0 ;
36135 char * kwnames[] = {
36136 (char *) "self",(char *) "orient", NULL
36137 };
36138
36139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36141 if (!SWIG_IsOK(res1)) {
36142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36143 }
36144 arg1 = reinterpret_cast< wxWindow * >(argp1);
36145 ecode2 = SWIG_AsVal_int(obj1, &val2);
36146 if (!SWIG_IsOK(ecode2)) {
36147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36148 }
36149 arg2 = static_cast< int >(val2);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 {
36157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36158 }
36159 return resultobj;
36160 fail:
36161 return NULL;
36162 }
36163
36164
36165 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36166 PyObject *resultobj = 0;
36167 wxWindow *arg1 = (wxWindow *) 0 ;
36168 int arg2 ;
36169 int arg3 ;
36170 int arg4 ;
36171 int arg5 ;
36172 bool arg6 = (bool) true ;
36173 void *argp1 = 0 ;
36174 int res1 = 0 ;
36175 int val2 ;
36176 int ecode2 = 0 ;
36177 int val3 ;
36178 int ecode3 = 0 ;
36179 int val4 ;
36180 int ecode4 = 0 ;
36181 int val5 ;
36182 int ecode5 = 0 ;
36183 bool val6 ;
36184 int ecode6 = 0 ;
36185 PyObject * obj0 = 0 ;
36186 PyObject * obj1 = 0 ;
36187 PyObject * obj2 = 0 ;
36188 PyObject * obj3 = 0 ;
36189 PyObject * obj4 = 0 ;
36190 PyObject * obj5 = 0 ;
36191 char * kwnames[] = {
36192 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36193 };
36194
36195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36197 if (!SWIG_IsOK(res1)) {
36198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36199 }
36200 arg1 = reinterpret_cast< wxWindow * >(argp1);
36201 ecode2 = SWIG_AsVal_int(obj1, &val2);
36202 if (!SWIG_IsOK(ecode2)) {
36203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36204 }
36205 arg2 = static_cast< int >(val2);
36206 ecode3 = SWIG_AsVal_int(obj2, &val3);
36207 if (!SWIG_IsOK(ecode3)) {
36208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36209 }
36210 arg3 = static_cast< int >(val3);
36211 ecode4 = SWIG_AsVal_int(obj3, &val4);
36212 if (!SWIG_IsOK(ecode4)) {
36213 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36214 }
36215 arg4 = static_cast< int >(val4);
36216 ecode5 = SWIG_AsVal_int(obj4, &val5);
36217 if (!SWIG_IsOK(ecode5)) {
36218 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36219 }
36220 arg5 = static_cast< int >(val5);
36221 if (obj5) {
36222 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36223 if (!SWIG_IsOK(ecode6)) {
36224 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36225 }
36226 arg6 = static_cast< bool >(val6);
36227 }
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 resultobj = SWIG_Py_Void();
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 int arg2 ;
36245 int arg3 ;
36246 bool arg4 = (bool) true ;
36247 void *argp1 = 0 ;
36248 int res1 = 0 ;
36249 int val2 ;
36250 int ecode2 = 0 ;
36251 int val3 ;
36252 int ecode3 = 0 ;
36253 bool val4 ;
36254 int ecode4 = 0 ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 PyObject * obj2 = 0 ;
36258 PyObject * obj3 = 0 ;
36259 char * kwnames[] = {
36260 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36261 };
36262
36263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36265 if (!SWIG_IsOK(res1)) {
36266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36267 }
36268 arg1 = reinterpret_cast< wxWindow * >(argp1);
36269 ecode2 = SWIG_AsVal_int(obj1, &val2);
36270 if (!SWIG_IsOK(ecode2)) {
36271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36272 }
36273 arg2 = static_cast< int >(val2);
36274 ecode3 = SWIG_AsVal_int(obj2, &val3);
36275 if (!SWIG_IsOK(ecode3)) {
36276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36277 }
36278 arg3 = static_cast< int >(val3);
36279 if (obj3) {
36280 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36281 if (!SWIG_IsOK(ecode4)) {
36282 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36283 }
36284 arg4 = static_cast< bool >(val4);
36285 }
36286 {
36287 PyThreadState* __tstate = wxPyBeginAllowThreads();
36288 (arg1)->SetScrollPos(arg2,arg3,arg4);
36289 wxPyEndAllowThreads(__tstate);
36290 if (PyErr_Occurred()) SWIG_fail;
36291 }
36292 resultobj = SWIG_Py_Void();
36293 return resultobj;
36294 fail:
36295 return NULL;
36296 }
36297
36298
36299 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36300 PyObject *resultobj = 0;
36301 wxWindow *arg1 = (wxWindow *) 0 ;
36302 int arg2 ;
36303 int result;
36304 void *argp1 = 0 ;
36305 int res1 = 0 ;
36306 int val2 ;
36307 int ecode2 = 0 ;
36308 PyObject * obj0 = 0 ;
36309 PyObject * obj1 = 0 ;
36310 char * kwnames[] = {
36311 (char *) "self",(char *) "orientation", NULL
36312 };
36313
36314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36318 }
36319 arg1 = reinterpret_cast< wxWindow * >(argp1);
36320 ecode2 = SWIG_AsVal_int(obj1, &val2);
36321 if (!SWIG_IsOK(ecode2)) {
36322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36323 }
36324 arg2 = static_cast< int >(val2);
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36328 wxPyEndAllowThreads(__tstate);
36329 if (PyErr_Occurred()) SWIG_fail;
36330 }
36331 resultobj = SWIG_From_int(static_cast< int >(result));
36332 return resultobj;
36333 fail:
36334 return NULL;
36335 }
36336
36337
36338 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36339 PyObject *resultobj = 0;
36340 wxWindow *arg1 = (wxWindow *) 0 ;
36341 int arg2 ;
36342 int result;
36343 void *argp1 = 0 ;
36344 int res1 = 0 ;
36345 int val2 ;
36346 int ecode2 = 0 ;
36347 PyObject * obj0 = 0 ;
36348 PyObject * obj1 = 0 ;
36349 char * kwnames[] = {
36350 (char *) "self",(char *) "orientation", NULL
36351 };
36352
36353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36355 if (!SWIG_IsOK(res1)) {
36356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36357 }
36358 arg1 = reinterpret_cast< wxWindow * >(argp1);
36359 ecode2 = SWIG_AsVal_int(obj1, &val2);
36360 if (!SWIG_IsOK(ecode2)) {
36361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36362 }
36363 arg2 = static_cast< int >(val2);
36364 {
36365 PyThreadState* __tstate = wxPyBeginAllowThreads();
36366 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36367 wxPyEndAllowThreads(__tstate);
36368 if (PyErr_Occurred()) SWIG_fail;
36369 }
36370 resultobj = SWIG_From_int(static_cast< int >(result));
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 int arg2 ;
36381 int result;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 int val2 ;
36385 int ecode2 = 0 ;
36386 PyObject * obj0 = 0 ;
36387 PyObject * obj1 = 0 ;
36388 char * kwnames[] = {
36389 (char *) "self",(char *) "orientation", NULL
36390 };
36391
36392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36394 if (!SWIG_IsOK(res1)) {
36395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36396 }
36397 arg1 = reinterpret_cast< wxWindow * >(argp1);
36398 ecode2 = SWIG_AsVal_int(obj1, &val2);
36399 if (!SWIG_IsOK(ecode2)) {
36400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36401 }
36402 arg2 = static_cast< int >(val2);
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 resultobj = SWIG_From_int(static_cast< int >(result));
36410 return resultobj;
36411 fail:
36412 return NULL;
36413 }
36414
36415
36416 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36417 PyObject *resultobj = 0;
36418 wxWindow *arg1 = (wxWindow *) 0 ;
36419 int arg2 ;
36420 int arg3 ;
36421 wxRect *arg4 = (wxRect *) NULL ;
36422 void *argp1 = 0 ;
36423 int res1 = 0 ;
36424 int val2 ;
36425 int ecode2 = 0 ;
36426 int val3 ;
36427 int ecode3 = 0 ;
36428 void *argp4 = 0 ;
36429 int res4 = 0 ;
36430 PyObject * obj0 = 0 ;
36431 PyObject * obj1 = 0 ;
36432 PyObject * obj2 = 0 ;
36433 PyObject * obj3 = 0 ;
36434 char * kwnames[] = {
36435 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36436 };
36437
36438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36440 if (!SWIG_IsOK(res1)) {
36441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36442 }
36443 arg1 = reinterpret_cast< wxWindow * >(argp1);
36444 ecode2 = SWIG_AsVal_int(obj1, &val2);
36445 if (!SWIG_IsOK(ecode2)) {
36446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36447 }
36448 arg2 = static_cast< int >(val2);
36449 ecode3 = SWIG_AsVal_int(obj2, &val3);
36450 if (!SWIG_IsOK(ecode3)) {
36451 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36452 }
36453 arg3 = static_cast< int >(val3);
36454 if (obj3) {
36455 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36456 if (!SWIG_IsOK(res4)) {
36457 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36458 }
36459 arg4 = reinterpret_cast< wxRect * >(argp4);
36460 }
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 resultobj = SWIG_Py_Void();
36468 return resultobj;
36469 fail:
36470 return NULL;
36471 }
36472
36473
36474 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36475 PyObject *resultobj = 0;
36476 wxWindow *arg1 = (wxWindow *) 0 ;
36477 int arg2 ;
36478 bool result;
36479 void *argp1 = 0 ;
36480 int res1 = 0 ;
36481 int val2 ;
36482 int ecode2 = 0 ;
36483 PyObject * obj0 = 0 ;
36484 PyObject * obj1 = 0 ;
36485 char * kwnames[] = {
36486 (char *) "self",(char *) "lines", NULL
36487 };
36488
36489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36491 if (!SWIG_IsOK(res1)) {
36492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36493 }
36494 arg1 = reinterpret_cast< wxWindow * >(argp1);
36495 ecode2 = SWIG_AsVal_int(obj1, &val2);
36496 if (!SWIG_IsOK(ecode2)) {
36497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36498 }
36499 arg2 = static_cast< int >(val2);
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 result = (bool)(arg1)->ScrollLines(arg2);
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 {
36507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36508 }
36509 return resultobj;
36510 fail:
36511 return NULL;
36512 }
36513
36514
36515 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36516 PyObject *resultobj = 0;
36517 wxWindow *arg1 = (wxWindow *) 0 ;
36518 int arg2 ;
36519 bool result;
36520 void *argp1 = 0 ;
36521 int res1 = 0 ;
36522 int val2 ;
36523 int ecode2 = 0 ;
36524 PyObject * obj0 = 0 ;
36525 PyObject * obj1 = 0 ;
36526 char * kwnames[] = {
36527 (char *) "self",(char *) "pages", NULL
36528 };
36529
36530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36532 if (!SWIG_IsOK(res1)) {
36533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36534 }
36535 arg1 = reinterpret_cast< wxWindow * >(argp1);
36536 ecode2 = SWIG_AsVal_int(obj1, &val2);
36537 if (!SWIG_IsOK(ecode2)) {
36538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36539 }
36540 arg2 = static_cast< int >(val2);
36541 {
36542 PyThreadState* __tstate = wxPyBeginAllowThreads();
36543 result = (bool)(arg1)->ScrollPages(arg2);
36544 wxPyEndAllowThreads(__tstate);
36545 if (PyErr_Occurred()) SWIG_fail;
36546 }
36547 {
36548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36549 }
36550 return resultobj;
36551 fail:
36552 return NULL;
36553 }
36554
36555
36556 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36557 PyObject *resultobj = 0;
36558 wxWindow *arg1 = (wxWindow *) 0 ;
36559 bool result;
36560 void *argp1 = 0 ;
36561 int res1 = 0 ;
36562 PyObject *swig_obj[1] ;
36563
36564 if (!args) SWIG_fail;
36565 swig_obj[0] = args;
36566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36567 if (!SWIG_IsOK(res1)) {
36568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36569 }
36570 arg1 = reinterpret_cast< wxWindow * >(argp1);
36571 {
36572 PyThreadState* __tstate = wxPyBeginAllowThreads();
36573 result = (bool)(arg1)->LineUp();
36574 wxPyEndAllowThreads(__tstate);
36575 if (PyErr_Occurred()) SWIG_fail;
36576 }
36577 {
36578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36579 }
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 bool result;
36590 void *argp1 = 0 ;
36591 int res1 = 0 ;
36592 PyObject *swig_obj[1] ;
36593
36594 if (!args) SWIG_fail;
36595 swig_obj[0] = args;
36596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36597 if (!SWIG_IsOK(res1)) {
36598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36599 }
36600 arg1 = reinterpret_cast< wxWindow * >(argp1);
36601 {
36602 PyThreadState* __tstate = wxPyBeginAllowThreads();
36603 result = (bool)(arg1)->LineDown();
36604 wxPyEndAllowThreads(__tstate);
36605 if (PyErr_Occurred()) SWIG_fail;
36606 }
36607 {
36608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36609 }
36610 return resultobj;
36611 fail:
36612 return NULL;
36613 }
36614
36615
36616 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36617 PyObject *resultobj = 0;
36618 wxWindow *arg1 = (wxWindow *) 0 ;
36619 bool result;
36620 void *argp1 = 0 ;
36621 int res1 = 0 ;
36622 PyObject *swig_obj[1] ;
36623
36624 if (!args) SWIG_fail;
36625 swig_obj[0] = args;
36626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36627 if (!SWIG_IsOK(res1)) {
36628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36629 }
36630 arg1 = reinterpret_cast< wxWindow * >(argp1);
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 result = (bool)(arg1)->PageUp();
36634 wxPyEndAllowThreads(__tstate);
36635 if (PyErr_Occurred()) SWIG_fail;
36636 }
36637 {
36638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36639 }
36640 return resultobj;
36641 fail:
36642 return NULL;
36643 }
36644
36645
36646 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36647 PyObject *resultobj = 0;
36648 wxWindow *arg1 = (wxWindow *) 0 ;
36649 bool result;
36650 void *argp1 = 0 ;
36651 int res1 = 0 ;
36652 PyObject *swig_obj[1] ;
36653
36654 if (!args) SWIG_fail;
36655 swig_obj[0] = args;
36656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36659 }
36660 arg1 = reinterpret_cast< wxWindow * >(argp1);
36661 {
36662 PyThreadState* __tstate = wxPyBeginAllowThreads();
36663 result = (bool)(arg1)->PageDown();
36664 wxPyEndAllowThreads(__tstate);
36665 if (PyErr_Occurred()) SWIG_fail;
36666 }
36667 {
36668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36669 }
36670 return resultobj;
36671 fail:
36672 return NULL;
36673 }
36674
36675
36676 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj = 0;
36678 wxWindow *arg1 = (wxWindow *) 0 ;
36679 wxString *arg2 = 0 ;
36680 void *argp1 = 0 ;
36681 int res1 = 0 ;
36682 bool temp2 = false ;
36683 PyObject * obj0 = 0 ;
36684 PyObject * obj1 = 0 ;
36685 char * kwnames[] = {
36686 (char *) "self",(char *) "text", NULL
36687 };
36688
36689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36691 if (!SWIG_IsOK(res1)) {
36692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36693 }
36694 arg1 = reinterpret_cast< wxWindow * >(argp1);
36695 {
36696 arg2 = wxString_in_helper(obj1);
36697 if (arg2 == NULL) SWIG_fail;
36698 temp2 = true;
36699 }
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 (arg1)->SetHelpText((wxString const &)*arg2);
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = SWIG_Py_Void();
36707 {
36708 if (temp2)
36709 delete arg2;
36710 }
36711 return resultobj;
36712 fail:
36713 {
36714 if (temp2)
36715 delete arg2;
36716 }
36717 return NULL;
36718 }
36719
36720
36721 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36722 PyObject *resultobj = 0;
36723 wxWindow *arg1 = (wxWindow *) 0 ;
36724 wxString *arg2 = 0 ;
36725 void *argp1 = 0 ;
36726 int res1 = 0 ;
36727 bool temp2 = false ;
36728 PyObject * obj0 = 0 ;
36729 PyObject * obj1 = 0 ;
36730 char * kwnames[] = {
36731 (char *) "self",(char *) "text", NULL
36732 };
36733
36734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36736 if (!SWIG_IsOK(res1)) {
36737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36738 }
36739 arg1 = reinterpret_cast< wxWindow * >(argp1);
36740 {
36741 arg2 = wxString_in_helper(obj1);
36742 if (arg2 == NULL) SWIG_fail;
36743 temp2 = true;
36744 }
36745 {
36746 PyThreadState* __tstate = wxPyBeginAllowThreads();
36747 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 resultobj = SWIG_Py_Void();
36752 {
36753 if (temp2)
36754 delete arg2;
36755 }
36756 return resultobj;
36757 fail:
36758 {
36759 if (temp2)
36760 delete arg2;
36761 }
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36767 PyObject *resultobj = 0;
36768 wxWindow *arg1 = (wxWindow *) 0 ;
36769 wxString result;
36770 void *argp1 = 0 ;
36771 int res1 = 0 ;
36772 PyObject *swig_obj[1] ;
36773
36774 if (!args) SWIG_fail;
36775 swig_obj[0] = args;
36776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36777 if (!SWIG_IsOK(res1)) {
36778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36779 }
36780 arg1 = reinterpret_cast< wxWindow * >(argp1);
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = ((wxWindow const *)arg1)->GetHelpText();
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 #if wxUSE_UNICODE
36789 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36790 #else
36791 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36792 #endif
36793 }
36794 return resultobj;
36795 fail:
36796 return NULL;
36797 }
36798
36799
36800 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36801 PyObject *resultobj = 0;
36802 wxWindow *arg1 = (wxWindow *) 0 ;
36803 wxString *arg2 = 0 ;
36804 void *argp1 = 0 ;
36805 int res1 = 0 ;
36806 bool temp2 = false ;
36807 PyObject * obj0 = 0 ;
36808 PyObject * obj1 = 0 ;
36809 char * kwnames[] = {
36810 (char *) "self",(char *) "tip", NULL
36811 };
36812
36813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36815 if (!SWIG_IsOK(res1)) {
36816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36817 }
36818 arg1 = reinterpret_cast< wxWindow * >(argp1);
36819 {
36820 arg2 = wxString_in_helper(obj1);
36821 if (arg2 == NULL) SWIG_fail;
36822 temp2 = true;
36823 }
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 (arg1)->SetToolTip((wxString const &)*arg2);
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 resultobj = SWIG_Py_Void();
36831 {
36832 if (temp2)
36833 delete arg2;
36834 }
36835 return resultobj;
36836 fail:
36837 {
36838 if (temp2)
36839 delete arg2;
36840 }
36841 return NULL;
36842 }
36843
36844
36845 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj = 0;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 wxToolTip *arg2 = (wxToolTip *) 0 ;
36849 void *argp1 = 0 ;
36850 int res1 = 0 ;
36851 int res2 = 0 ;
36852 PyObject * obj0 = 0 ;
36853 PyObject * obj1 = 0 ;
36854 char * kwnames[] = {
36855 (char *) "self",(char *) "tip", NULL
36856 };
36857
36858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36865 if (!SWIG_IsOK(res2)) {
36866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36867 }
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 (arg1)->SetToolTip(arg2);
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 resultobj = SWIG_Py_Void();
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxWindow *arg1 = (wxWindow *) 0 ;
36884 wxToolTip *result = 0 ;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 resultobj = wxPyMake_wxObject(result, (bool)0);
36904 }
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = 0;
36913 wxWindow *arg1 = (wxWindow *) 0 ;
36914 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 int res2 = 0 ;
36918 PyObject * obj0 = 0 ;
36919 PyObject * obj1 = 0 ;
36920 char * kwnames[] = {
36921 (char *) "self",(char *) "dropTarget", NULL
36922 };
36923
36924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36926 if (!SWIG_IsOK(res1)) {
36927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36928 }
36929 arg1 = reinterpret_cast< wxWindow * >(argp1);
36930 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36931 if (!SWIG_IsOK(res2)) {
36932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36933 }
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 (arg1)->SetDropTarget(arg2);
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 resultobj = SWIG_Py_Void();
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36948 PyObject *resultobj = 0;
36949 wxWindow *arg1 = (wxWindow *) 0 ;
36950 wxPyDropTarget *result = 0 ;
36951 void *argp1 = 0 ;
36952 int res1 = 0 ;
36953 PyObject *swig_obj[1] ;
36954
36955 if (!args) SWIG_fail;
36956 swig_obj[0] = args;
36957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36958 if (!SWIG_IsOK(res1)) {
36959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36960 }
36961 arg1 = reinterpret_cast< wxWindow * >(argp1);
36962 {
36963 PyThreadState* __tstate = wxPyBeginAllowThreads();
36964 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36965 wxPyEndAllowThreads(__tstate);
36966 if (PyErr_Occurred()) SWIG_fail;
36967 }
36968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36969 return resultobj;
36970 fail:
36971 return NULL;
36972 }
36973
36974
36975 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36976 PyObject *resultobj = 0;
36977 wxWindow *arg1 = (wxWindow *) 0 ;
36978 bool arg2 ;
36979 void *argp1 = 0 ;
36980 int res1 = 0 ;
36981 bool val2 ;
36982 int ecode2 = 0 ;
36983 PyObject * obj0 = 0 ;
36984 PyObject * obj1 = 0 ;
36985 char * kwnames[] = {
36986 (char *) "self",(char *) "accept", NULL
36987 };
36988
36989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36991 if (!SWIG_IsOK(res1)) {
36992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36993 }
36994 arg1 = reinterpret_cast< wxWindow * >(argp1);
36995 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36996 if (!SWIG_IsOK(ecode2)) {
36997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36998 }
36999 arg2 = static_cast< bool >(val2);
37000 {
37001 PyThreadState* __tstate = wxPyBeginAllowThreads();
37002 wxWindow_DragAcceptFiles(arg1,arg2);
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 resultobj = SWIG_Py_Void();
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37014 PyObject *resultobj = 0;
37015 wxWindow *arg1 = (wxWindow *) 0 ;
37016 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 int res2 = 0 ;
37020 PyObject * obj0 = 0 ;
37021 PyObject * obj1 = 0 ;
37022 char * kwnames[] = {
37023 (char *) "self",(char *) "constraints", NULL
37024 };
37025
37026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37033 if (!SWIG_IsOK(res2)) {
37034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 (arg1)->SetConstraints(arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 resultobj = SWIG_Py_Void();
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 wxLayoutConstraints *result = 0 ;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 PyObject *swig_obj[1] ;
37056
37057 if (!args) SWIG_fail;
37058 swig_obj[0] = args;
37059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37071 return resultobj;
37072 fail:
37073 return NULL;
37074 }
37075
37076
37077 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37078 PyObject *resultobj = 0;
37079 wxWindow *arg1 = (wxWindow *) 0 ;
37080 bool arg2 ;
37081 void *argp1 = 0 ;
37082 int res1 = 0 ;
37083 bool val2 ;
37084 int ecode2 = 0 ;
37085 PyObject * obj0 = 0 ;
37086 PyObject * obj1 = 0 ;
37087 char * kwnames[] = {
37088 (char *) "self",(char *) "autoLayout", NULL
37089 };
37090
37091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37093 if (!SWIG_IsOK(res1)) {
37094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37095 }
37096 arg1 = reinterpret_cast< wxWindow * >(argp1);
37097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37098 if (!SWIG_IsOK(ecode2)) {
37099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37100 }
37101 arg2 = static_cast< bool >(val2);
37102 {
37103 PyThreadState* __tstate = wxPyBeginAllowThreads();
37104 (arg1)->SetAutoLayout(arg2);
37105 wxPyEndAllowThreads(__tstate);
37106 if (PyErr_Occurred()) SWIG_fail;
37107 }
37108 resultobj = SWIG_Py_Void();
37109 return resultobj;
37110 fail:
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 bool result;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 PyObject *swig_obj[1] ;
37122
37123 if (!args) SWIG_fail;
37124 swig_obj[0] = args;
37125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37126 if (!SWIG_IsOK(res1)) {
37127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37128 }
37129 arg1 = reinterpret_cast< wxWindow * >(argp1);
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 {
37137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37138 }
37139 return resultobj;
37140 fail:
37141 return NULL;
37142 }
37143
37144
37145 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37146 PyObject *resultobj = 0;
37147 wxWindow *arg1 = (wxWindow *) 0 ;
37148 bool result;
37149 void *argp1 = 0 ;
37150 int res1 = 0 ;
37151 PyObject *swig_obj[1] ;
37152
37153 if (!args) SWIG_fail;
37154 swig_obj[0] = args;
37155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37156 if (!SWIG_IsOK(res1)) {
37157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37158 }
37159 arg1 = reinterpret_cast< wxWindow * >(argp1);
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (bool)(arg1)->Layout();
37163 wxPyEndAllowThreads(__tstate);
37164 if (PyErr_Occurred()) SWIG_fail;
37165 }
37166 {
37167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37168 }
37169 return resultobj;
37170 fail:
37171 return NULL;
37172 }
37173
37174
37175 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37176 PyObject *resultobj = 0;
37177 wxWindow *arg1 = (wxWindow *) 0 ;
37178 wxSizer *arg2 = (wxSizer *) 0 ;
37179 bool arg3 = (bool) true ;
37180 void *argp1 = 0 ;
37181 int res1 = 0 ;
37182 int res2 = 0 ;
37183 bool val3 ;
37184 int ecode3 = 0 ;
37185 PyObject * obj0 = 0 ;
37186 PyObject * obj1 = 0 ;
37187 PyObject * obj2 = 0 ;
37188 char * kwnames[] = {
37189 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37190 };
37191
37192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37194 if (!SWIG_IsOK(res1)) {
37195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37196 }
37197 arg1 = reinterpret_cast< wxWindow * >(argp1);
37198 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37199 if (!SWIG_IsOK(res2)) {
37200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37201 }
37202 if (obj2) {
37203 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37204 if (!SWIG_IsOK(ecode3)) {
37205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37206 }
37207 arg3 = static_cast< bool >(val3);
37208 }
37209 {
37210 PyThreadState* __tstate = wxPyBeginAllowThreads();
37211 (arg1)->SetSizer(arg2,arg3);
37212 wxPyEndAllowThreads(__tstate);
37213 if (PyErr_Occurred()) SWIG_fail;
37214 }
37215 resultobj = SWIG_Py_Void();
37216 return resultobj;
37217 fail:
37218 return NULL;
37219 }
37220
37221
37222 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37223 PyObject *resultobj = 0;
37224 wxWindow *arg1 = (wxWindow *) 0 ;
37225 wxSizer *arg2 = (wxSizer *) 0 ;
37226 bool arg3 = (bool) true ;
37227 void *argp1 = 0 ;
37228 int res1 = 0 ;
37229 int res2 = 0 ;
37230 bool val3 ;
37231 int ecode3 = 0 ;
37232 PyObject * obj0 = 0 ;
37233 PyObject * obj1 = 0 ;
37234 PyObject * obj2 = 0 ;
37235 char * kwnames[] = {
37236 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37237 };
37238
37239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37241 if (!SWIG_IsOK(res1)) {
37242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37243 }
37244 arg1 = reinterpret_cast< wxWindow * >(argp1);
37245 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37246 if (!SWIG_IsOK(res2)) {
37247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37248 }
37249 if (obj2) {
37250 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37251 if (!SWIG_IsOK(ecode3)) {
37252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37253 }
37254 arg3 = static_cast< bool >(val3);
37255 }
37256 {
37257 PyThreadState* __tstate = wxPyBeginAllowThreads();
37258 (arg1)->SetSizerAndFit(arg2,arg3);
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 resultobj = SWIG_Py_Void();
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37270 PyObject *resultobj = 0;
37271 wxWindow *arg1 = (wxWindow *) 0 ;
37272 wxSizer *result = 0 ;
37273 void *argp1 = 0 ;
37274 int res1 = 0 ;
37275 PyObject *swig_obj[1] ;
37276
37277 if (!args) SWIG_fail;
37278 swig_obj[0] = args;
37279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37280 if (!SWIG_IsOK(res1)) {
37281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37282 }
37283 arg1 = reinterpret_cast< wxWindow * >(argp1);
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 {
37291 resultobj = wxPyMake_wxObject(result, (bool)0);
37292 }
37293 return resultobj;
37294 fail:
37295 return NULL;
37296 }
37297
37298
37299 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37300 PyObject *resultobj = 0;
37301 wxWindow *arg1 = (wxWindow *) 0 ;
37302 wxSizer *arg2 = (wxSizer *) 0 ;
37303 void *argp1 = 0 ;
37304 int res1 = 0 ;
37305 void *argp2 = 0 ;
37306 int res2 = 0 ;
37307 PyObject * obj0 = 0 ;
37308 PyObject * obj1 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "sizer", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37320 if (!SWIG_IsOK(res2)) {
37321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37322 }
37323 arg2 = reinterpret_cast< wxSizer * >(argp2);
37324 {
37325 PyThreadState* __tstate = wxPyBeginAllowThreads();
37326 (arg1)->SetContainingSizer(arg2);
37327 wxPyEndAllowThreads(__tstate);
37328 if (PyErr_Occurred()) SWIG_fail;
37329 }
37330 resultobj = SWIG_Py_Void();
37331 return resultobj;
37332 fail:
37333 return NULL;
37334 }
37335
37336
37337 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37338 PyObject *resultobj = 0;
37339 wxWindow *arg1 = (wxWindow *) 0 ;
37340 wxSizer *result = 0 ;
37341 void *argp1 = 0 ;
37342 int res1 = 0 ;
37343 PyObject *swig_obj[1] ;
37344
37345 if (!args) SWIG_fail;
37346 swig_obj[0] = args;
37347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37348 if (!SWIG_IsOK(res1)) {
37349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37350 }
37351 arg1 = reinterpret_cast< wxWindow * >(argp1);
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 {
37359 resultobj = wxPyMake_wxObject(result, (bool)0);
37360 }
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37368 PyObject *resultobj = 0;
37369 wxWindow *arg1 = (wxWindow *) 0 ;
37370 void *argp1 = 0 ;
37371 int res1 = 0 ;
37372 PyObject *swig_obj[1] ;
37373
37374 if (!args) SWIG_fail;
37375 swig_obj[0] = args;
37376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37377 if (!SWIG_IsOK(res1)) {
37378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37379 }
37380 arg1 = reinterpret_cast< wxWindow * >(argp1);
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 (arg1)->InheritAttributes();
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_Py_Void();
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 bool result;
37398 void *argp1 = 0 ;
37399 int res1 = 0 ;
37400 PyObject *swig_obj[1] ;
37401
37402 if (!args) SWIG_fail;
37403 swig_obj[0] = args;
37404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37405 if (!SWIG_IsOK(res1)) {
37406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37407 }
37408 arg1 = reinterpret_cast< wxWindow * >(argp1);
37409 {
37410 PyThreadState* __tstate = wxPyBeginAllowThreads();
37411 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37412 wxPyEndAllowThreads(__tstate);
37413 if (PyErr_Occurred()) SWIG_fail;
37414 }
37415 {
37416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37417 }
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *obj;
37426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37427 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37428 return SWIG_Py_Void();
37429 }
37430
37431 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37432 return SWIG_Python_InitShadowInstance(args);
37433 }
37434
37435 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37436 PyObject *resultobj = 0;
37437 long arg1 ;
37438 wxWindow *arg2 = (wxWindow *) NULL ;
37439 wxWindow *result = 0 ;
37440 long val1 ;
37441 int ecode1 = 0 ;
37442 void *argp2 = 0 ;
37443 int res2 = 0 ;
37444 PyObject * obj0 = 0 ;
37445 PyObject * obj1 = 0 ;
37446 char * kwnames[] = {
37447 (char *) "id",(char *) "parent", NULL
37448 };
37449
37450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37451 ecode1 = SWIG_AsVal_long(obj0, &val1);
37452 if (!SWIG_IsOK(ecode1)) {
37453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37454 }
37455 arg1 = static_cast< long >(val1);
37456 if (obj1) {
37457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37458 if (!SWIG_IsOK(res2)) {
37459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37460 }
37461 arg2 = reinterpret_cast< wxWindow * >(argp2);
37462 }
37463 {
37464 if (!wxPyCheckForApp()) SWIG_fail;
37465 PyThreadState* __tstate = wxPyBeginAllowThreads();
37466 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37467 wxPyEndAllowThreads(__tstate);
37468 if (PyErr_Occurred()) SWIG_fail;
37469 }
37470 {
37471 resultobj = wxPyMake_wxObject(result, 0);
37472 }
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37480 PyObject *resultobj = 0;
37481 wxString *arg1 = 0 ;
37482 wxWindow *arg2 = (wxWindow *) NULL ;
37483 wxWindow *result = 0 ;
37484 bool temp1 = false ;
37485 void *argp2 = 0 ;
37486 int res2 = 0 ;
37487 PyObject * obj0 = 0 ;
37488 PyObject * obj1 = 0 ;
37489 char * kwnames[] = {
37490 (char *) "name",(char *) "parent", NULL
37491 };
37492
37493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37494 {
37495 arg1 = wxString_in_helper(obj0);
37496 if (arg1 == NULL) SWIG_fail;
37497 temp1 = true;
37498 }
37499 if (obj1) {
37500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37501 if (!SWIG_IsOK(res2)) {
37502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37503 }
37504 arg2 = reinterpret_cast< wxWindow * >(argp2);
37505 }
37506 {
37507 if (!wxPyCheckForApp()) SWIG_fail;
37508 PyThreadState* __tstate = wxPyBeginAllowThreads();
37509 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37510 wxPyEndAllowThreads(__tstate);
37511 if (PyErr_Occurred()) SWIG_fail;
37512 }
37513 {
37514 resultobj = wxPyMake_wxObject(result, 0);
37515 }
37516 {
37517 if (temp1)
37518 delete arg1;
37519 }
37520 return resultobj;
37521 fail:
37522 {
37523 if (temp1)
37524 delete arg1;
37525 }
37526 return NULL;
37527 }
37528
37529
37530 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37531 PyObject *resultobj = 0;
37532 wxString *arg1 = 0 ;
37533 wxWindow *arg2 = (wxWindow *) NULL ;
37534 wxWindow *result = 0 ;
37535 bool temp1 = false ;
37536 void *argp2 = 0 ;
37537 int res2 = 0 ;
37538 PyObject * obj0 = 0 ;
37539 PyObject * obj1 = 0 ;
37540 char * kwnames[] = {
37541 (char *) "label",(char *) "parent", NULL
37542 };
37543
37544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37545 {
37546 arg1 = wxString_in_helper(obj0);
37547 if (arg1 == NULL) SWIG_fail;
37548 temp1 = true;
37549 }
37550 if (obj1) {
37551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37552 if (!SWIG_IsOK(res2)) {
37553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37554 }
37555 arg2 = reinterpret_cast< wxWindow * >(argp2);
37556 }
37557 {
37558 if (!wxPyCheckForApp()) SWIG_fail;
37559 PyThreadState* __tstate = wxPyBeginAllowThreads();
37560 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37561 wxPyEndAllowThreads(__tstate);
37562 if (PyErr_Occurred()) SWIG_fail;
37563 }
37564 {
37565 resultobj = wxPyMake_wxObject(result, 0);
37566 }
37567 {
37568 if (temp1)
37569 delete arg1;
37570 }
37571 return resultobj;
37572 fail:
37573 {
37574 if (temp1)
37575 delete arg1;
37576 }
37577 return NULL;
37578 }
37579
37580
37581 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37582 PyObject *resultobj = 0;
37583 wxWindow *arg1 = (wxWindow *) 0 ;
37584 unsigned long arg2 ;
37585 wxWindow *result = 0 ;
37586 void *argp1 = 0 ;
37587 int res1 = 0 ;
37588 unsigned long val2 ;
37589 int ecode2 = 0 ;
37590 PyObject * obj0 = 0 ;
37591 PyObject * obj1 = 0 ;
37592 char * kwnames[] = {
37593 (char *) "parent",(char *) "_hWnd", NULL
37594 };
37595
37596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37598 if (!SWIG_IsOK(res1)) {
37599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37600 }
37601 arg1 = reinterpret_cast< wxWindow * >(argp1);
37602 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37603 if (!SWIG_IsOK(ecode2)) {
37604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37605 }
37606 arg2 = static_cast< unsigned long >(val2);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 {
37614 resultobj = wxPyMake_wxObject(result, 0);
37615 }
37616 return resultobj;
37617 fail:
37618 return NULL;
37619 }
37620
37621
37622 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37623 PyObject *resultobj = 0;
37624 PyObject *result = 0 ;
37625
37626 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37627 {
37628 PyThreadState* __tstate = wxPyBeginAllowThreads();
37629 result = (PyObject *)GetTopLevelWindows();
37630 wxPyEndAllowThreads(__tstate);
37631 if (PyErr_Occurred()) SWIG_fail;
37632 }
37633 resultobj = result;
37634 return resultobj;
37635 fail:
37636 return NULL;
37637 }
37638
37639
37640 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37641 PyObject *resultobj = 0;
37642 wxValidator *result = 0 ;
37643
37644 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37645 {
37646 PyThreadState* __tstate = wxPyBeginAllowThreads();
37647 result = (wxValidator *)new wxValidator();
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37652 return resultobj;
37653 fail:
37654 return NULL;
37655 }
37656
37657
37658 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37659 PyObject *resultobj = 0;
37660 wxValidator *arg1 = (wxValidator *) 0 ;
37661 wxValidator *result = 0 ;
37662 void *argp1 = 0 ;
37663 int res1 = 0 ;
37664 PyObject *swig_obj[1] ;
37665
37666 if (!args) SWIG_fail;
37667 swig_obj[0] = args;
37668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37669 if (!SWIG_IsOK(res1)) {
37670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37671 }
37672 arg1 = reinterpret_cast< wxValidator * >(argp1);
37673 {
37674 PyThreadState* __tstate = wxPyBeginAllowThreads();
37675 result = (wxValidator *)(arg1)->Clone();
37676 wxPyEndAllowThreads(__tstate);
37677 if (PyErr_Occurred()) SWIG_fail;
37678 }
37679 {
37680 resultobj = wxPyMake_wxObject(result, 0);
37681 }
37682 return resultobj;
37683 fail:
37684 return NULL;
37685 }
37686
37687
37688 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37689 PyObject *resultobj = 0;
37690 wxValidator *arg1 = (wxValidator *) 0 ;
37691 wxWindow *arg2 = (wxWindow *) 0 ;
37692 bool result;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 void *argp2 = 0 ;
37696 int res2 = 0 ;
37697 PyObject * obj0 = 0 ;
37698 PyObject * obj1 = 0 ;
37699 char * kwnames[] = {
37700 (char *) "self",(char *) "parent", NULL
37701 };
37702
37703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37705 if (!SWIG_IsOK(res1)) {
37706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37707 }
37708 arg1 = reinterpret_cast< wxValidator * >(argp1);
37709 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37710 if (!SWIG_IsOK(res2)) {
37711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37712 }
37713 arg2 = reinterpret_cast< wxWindow * >(argp2);
37714 {
37715 PyThreadState* __tstate = wxPyBeginAllowThreads();
37716 result = (bool)(arg1)->Validate(arg2);
37717 wxPyEndAllowThreads(__tstate);
37718 if (PyErr_Occurred()) SWIG_fail;
37719 }
37720 {
37721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37722 }
37723 return resultobj;
37724 fail:
37725 return NULL;
37726 }
37727
37728
37729 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37730 PyObject *resultobj = 0;
37731 wxValidator *arg1 = (wxValidator *) 0 ;
37732 bool result;
37733 void *argp1 = 0 ;
37734 int res1 = 0 ;
37735 PyObject *swig_obj[1] ;
37736
37737 if (!args) SWIG_fail;
37738 swig_obj[0] = args;
37739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37740 if (!SWIG_IsOK(res1)) {
37741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37742 }
37743 arg1 = reinterpret_cast< wxValidator * >(argp1);
37744 {
37745 PyThreadState* __tstate = wxPyBeginAllowThreads();
37746 result = (bool)(arg1)->TransferToWindow();
37747 wxPyEndAllowThreads(__tstate);
37748 if (PyErr_Occurred()) SWIG_fail;
37749 }
37750 {
37751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37752 }
37753 return resultobj;
37754 fail:
37755 return NULL;
37756 }
37757
37758
37759 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37760 PyObject *resultobj = 0;
37761 wxValidator *arg1 = (wxValidator *) 0 ;
37762 bool result;
37763 void *argp1 = 0 ;
37764 int res1 = 0 ;
37765 PyObject *swig_obj[1] ;
37766
37767 if (!args) SWIG_fail;
37768 swig_obj[0] = args;
37769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37770 if (!SWIG_IsOK(res1)) {
37771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37772 }
37773 arg1 = reinterpret_cast< wxValidator * >(argp1);
37774 {
37775 PyThreadState* __tstate = wxPyBeginAllowThreads();
37776 result = (bool)(arg1)->TransferFromWindow();
37777 wxPyEndAllowThreads(__tstate);
37778 if (PyErr_Occurred()) SWIG_fail;
37779 }
37780 {
37781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37782 }
37783 return resultobj;
37784 fail:
37785 return NULL;
37786 }
37787
37788
37789 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37790 PyObject *resultobj = 0;
37791 wxValidator *arg1 = (wxValidator *) 0 ;
37792 wxWindow *result = 0 ;
37793 void *argp1 = 0 ;
37794 int res1 = 0 ;
37795 PyObject *swig_obj[1] ;
37796
37797 if (!args) SWIG_fail;
37798 swig_obj[0] = args;
37799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37800 if (!SWIG_IsOK(res1)) {
37801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37802 }
37803 arg1 = reinterpret_cast< wxValidator * >(argp1);
37804 {
37805 PyThreadState* __tstate = wxPyBeginAllowThreads();
37806 result = (wxWindow *)(arg1)->GetWindow();
37807 wxPyEndAllowThreads(__tstate);
37808 if (PyErr_Occurred()) SWIG_fail;
37809 }
37810 {
37811 resultobj = wxPyMake_wxObject(result, 0);
37812 }
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxValidator *arg1 = (wxValidator *) 0 ;
37822 wxWindow *arg2 = (wxWindow *) 0 ;
37823 void *argp1 = 0 ;
37824 int res1 = 0 ;
37825 void *argp2 = 0 ;
37826 int res2 = 0 ;
37827 PyObject * obj0 = 0 ;
37828 PyObject * obj1 = 0 ;
37829 char * kwnames[] = {
37830 (char *) "self",(char *) "window", NULL
37831 };
37832
37833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37837 }
37838 arg1 = reinterpret_cast< wxValidator * >(argp1);
37839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37840 if (!SWIG_IsOK(res2)) {
37841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37842 }
37843 arg2 = reinterpret_cast< wxWindow * >(argp2);
37844 {
37845 PyThreadState* __tstate = wxPyBeginAllowThreads();
37846 (arg1)->SetWindow(arg2);
37847 wxPyEndAllowThreads(__tstate);
37848 if (PyErr_Occurred()) SWIG_fail;
37849 }
37850 resultobj = SWIG_Py_Void();
37851 return resultobj;
37852 fail:
37853 return NULL;
37854 }
37855
37856
37857 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37858 PyObject *resultobj = 0;
37859 bool result;
37860
37861 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 result = (bool)wxValidator::IsSilent();
37865 wxPyEndAllowThreads(__tstate);
37866 if (PyErr_Occurred()) SWIG_fail;
37867 }
37868 {
37869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37870 }
37871 return resultobj;
37872 fail:
37873 return NULL;
37874 }
37875
37876
37877 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj = 0;
37879 int arg1 = (int) true ;
37880 int val1 ;
37881 int ecode1 = 0 ;
37882 PyObject * obj0 = 0 ;
37883 char * kwnames[] = {
37884 (char *) "doIt", NULL
37885 };
37886
37887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37888 if (obj0) {
37889 ecode1 = SWIG_AsVal_int(obj0, &val1);
37890 if (!SWIG_IsOK(ecode1)) {
37891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37892 }
37893 arg1 = static_cast< int >(val1);
37894 }
37895 {
37896 PyThreadState* __tstate = wxPyBeginAllowThreads();
37897 wxValidator::SetBellOnError(arg1);
37898 wxPyEndAllowThreads(__tstate);
37899 if (PyErr_Occurred()) SWIG_fail;
37900 }
37901 resultobj = SWIG_Py_Void();
37902 return resultobj;
37903 fail:
37904 return NULL;
37905 }
37906
37907
37908 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37909 PyObject *obj;
37910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37911 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37912 return SWIG_Py_Void();
37913 }
37914
37915 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37916 return SWIG_Python_InitShadowInstance(args);
37917 }
37918
37919 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37920 PyObject *resultobj = 0;
37921 wxPyValidator *result = 0 ;
37922
37923 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (wxPyValidator *)new wxPyValidator();
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37931 return resultobj;
37932 fail:
37933 return NULL;
37934 }
37935
37936
37937 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37938 PyObject *resultobj = 0;
37939 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37940 PyObject *arg2 = (PyObject *) 0 ;
37941 PyObject *arg3 = (PyObject *) 0 ;
37942 int arg4 = (int) true ;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 int val4 ;
37946 int ecode4 = 0 ;
37947 PyObject * obj0 = 0 ;
37948 PyObject * obj1 = 0 ;
37949 PyObject * obj2 = 0 ;
37950 PyObject * obj3 = 0 ;
37951 char * kwnames[] = {
37952 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37953 };
37954
37955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37957 if (!SWIG_IsOK(res1)) {
37958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37959 }
37960 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37961 arg2 = obj1;
37962 arg3 = obj2;
37963 if (obj3) {
37964 ecode4 = SWIG_AsVal_int(obj3, &val4);
37965 if (!SWIG_IsOK(ecode4)) {
37966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37967 }
37968 arg4 = static_cast< int >(val4);
37969 }
37970 {
37971 PyThreadState* __tstate = wxPyBeginAllowThreads();
37972 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37973 wxPyEndAllowThreads(__tstate);
37974 if (PyErr_Occurred()) SWIG_fail;
37975 }
37976 resultobj = SWIG_Py_Void();
37977 return resultobj;
37978 fail:
37979 return NULL;
37980 }
37981
37982
37983 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37984 PyObject *obj;
37985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37986 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37987 return SWIG_Py_Void();
37988 }
37989
37990 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37991 return SWIG_Python_InitShadowInstance(args);
37992 }
37993
37994 SWIGINTERN int DefaultValidator_set(PyObject *) {
37995 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37996 return 1;
37997 }
37998
37999
38000 SWIGINTERN PyObject *DefaultValidator_get(void) {
38001 PyObject *pyobj = 0;
38002
38003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38004 return pyobj;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj = 0;
38010 wxString const &arg1_defvalue = wxPyEmptyString ;
38011 wxString *arg1 = (wxString *) &arg1_defvalue ;
38012 long arg2 = (long) 0 ;
38013 wxMenu *result = 0 ;
38014 bool temp1 = false ;
38015 long val2 ;
38016 int ecode2 = 0 ;
38017 PyObject * obj0 = 0 ;
38018 PyObject * obj1 = 0 ;
38019 char * kwnames[] = {
38020 (char *) "title",(char *) "style", NULL
38021 };
38022
38023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38024 if (obj0) {
38025 {
38026 arg1 = wxString_in_helper(obj0);
38027 if (arg1 == NULL) SWIG_fail;
38028 temp1 = true;
38029 }
38030 }
38031 if (obj1) {
38032 ecode2 = SWIG_AsVal_long(obj1, &val2);
38033 if (!SWIG_IsOK(ecode2)) {
38034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38035 }
38036 arg2 = static_cast< long >(val2);
38037 }
38038 {
38039 if (!wxPyCheckForApp()) SWIG_fail;
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38046 {
38047 if (temp1)
38048 delete arg1;
38049 }
38050 return resultobj;
38051 fail:
38052 {
38053 if (temp1)
38054 delete arg1;
38055 }
38056 return NULL;
38057 }
38058
38059
38060 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = 0;
38062 wxMenu *arg1 = (wxMenu *) 0 ;
38063 int arg2 ;
38064 wxString *arg3 = 0 ;
38065 wxString const &arg4_defvalue = wxPyEmptyString ;
38066 wxString *arg4 = (wxString *) &arg4_defvalue ;
38067 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38068 wxMenuItem *result = 0 ;
38069 void *argp1 = 0 ;
38070 int res1 = 0 ;
38071 int val2 ;
38072 int ecode2 = 0 ;
38073 bool temp3 = false ;
38074 bool temp4 = false ;
38075 int val5 ;
38076 int ecode5 = 0 ;
38077 PyObject * obj0 = 0 ;
38078 PyObject * obj1 = 0 ;
38079 PyObject * obj2 = 0 ;
38080 PyObject * obj3 = 0 ;
38081 PyObject * obj4 = 0 ;
38082 char * kwnames[] = {
38083 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38084 };
38085
38086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38088 if (!SWIG_IsOK(res1)) {
38089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38090 }
38091 arg1 = reinterpret_cast< wxMenu * >(argp1);
38092 ecode2 = SWIG_AsVal_int(obj1, &val2);
38093 if (!SWIG_IsOK(ecode2)) {
38094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38095 }
38096 arg2 = static_cast< int >(val2);
38097 {
38098 arg3 = wxString_in_helper(obj2);
38099 if (arg3 == NULL) SWIG_fail;
38100 temp3 = true;
38101 }
38102 if (obj3) {
38103 {
38104 arg4 = wxString_in_helper(obj3);
38105 if (arg4 == NULL) SWIG_fail;
38106 temp4 = true;
38107 }
38108 }
38109 if (obj4) {
38110 ecode5 = SWIG_AsVal_int(obj4, &val5);
38111 if (!SWIG_IsOK(ecode5)) {
38112 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38113 }
38114 arg5 = static_cast< wxItemKind >(val5);
38115 }
38116 {
38117 PyThreadState* __tstate = wxPyBeginAllowThreads();
38118 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38119 wxPyEndAllowThreads(__tstate);
38120 if (PyErr_Occurred()) SWIG_fail;
38121 }
38122 {
38123 resultobj = wxPyMake_wxObject(result, (bool)0);
38124 }
38125 {
38126 if (temp3)
38127 delete arg3;
38128 }
38129 {
38130 if (temp4)
38131 delete arg4;
38132 }
38133 return resultobj;
38134 fail:
38135 {
38136 if (temp3)
38137 delete arg3;
38138 }
38139 {
38140 if (temp4)
38141 delete arg4;
38142 }
38143 return NULL;
38144 }
38145
38146
38147 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38148 PyObject *resultobj = 0;
38149 wxMenu *arg1 = (wxMenu *) 0 ;
38150 wxMenuItem *result = 0 ;
38151 void *argp1 = 0 ;
38152 int res1 = 0 ;
38153 PyObject *swig_obj[1] ;
38154
38155 if (!args) SWIG_fail;
38156 swig_obj[0] = args;
38157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38158 if (!SWIG_IsOK(res1)) {
38159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38160 }
38161 arg1 = reinterpret_cast< wxMenu * >(argp1);
38162 {
38163 PyThreadState* __tstate = wxPyBeginAllowThreads();
38164 result = (wxMenuItem *)(arg1)->AppendSeparator();
38165 wxPyEndAllowThreads(__tstate);
38166 if (PyErr_Occurred()) SWIG_fail;
38167 }
38168 {
38169 resultobj = wxPyMake_wxObject(result, (bool)0);
38170 }
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38178 PyObject *resultobj = 0;
38179 wxMenu *arg1 = (wxMenu *) 0 ;
38180 int arg2 ;
38181 wxString *arg3 = 0 ;
38182 wxString const &arg4_defvalue = wxPyEmptyString ;
38183 wxString *arg4 = (wxString *) &arg4_defvalue ;
38184 wxMenuItem *result = 0 ;
38185 void *argp1 = 0 ;
38186 int res1 = 0 ;
38187 int val2 ;
38188 int ecode2 = 0 ;
38189 bool temp3 = false ;
38190 bool temp4 = false ;
38191 PyObject * obj0 = 0 ;
38192 PyObject * obj1 = 0 ;
38193 PyObject * obj2 = 0 ;
38194 PyObject * obj3 = 0 ;
38195 char * kwnames[] = {
38196 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38197 };
38198
38199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38201 if (!SWIG_IsOK(res1)) {
38202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38203 }
38204 arg1 = reinterpret_cast< wxMenu * >(argp1);
38205 ecode2 = SWIG_AsVal_int(obj1, &val2);
38206 if (!SWIG_IsOK(ecode2)) {
38207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38208 }
38209 arg2 = static_cast< int >(val2);
38210 {
38211 arg3 = wxString_in_helper(obj2);
38212 if (arg3 == NULL) SWIG_fail;
38213 temp3 = true;
38214 }
38215 if (obj3) {
38216 {
38217 arg4 = wxString_in_helper(obj3);
38218 if (arg4 == NULL) SWIG_fail;
38219 temp4 = true;
38220 }
38221 }
38222 {
38223 PyThreadState* __tstate = wxPyBeginAllowThreads();
38224 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38225 wxPyEndAllowThreads(__tstate);
38226 if (PyErr_Occurred()) SWIG_fail;
38227 }
38228 {
38229 resultobj = wxPyMake_wxObject(result, (bool)0);
38230 }
38231 {
38232 if (temp3)
38233 delete arg3;
38234 }
38235 {
38236 if (temp4)
38237 delete arg4;
38238 }
38239 return resultobj;
38240 fail:
38241 {
38242 if (temp3)
38243 delete arg3;
38244 }
38245 {
38246 if (temp4)
38247 delete arg4;
38248 }
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj = 0;
38255 wxMenu *arg1 = (wxMenu *) 0 ;
38256 int arg2 ;
38257 wxString *arg3 = 0 ;
38258 wxString const &arg4_defvalue = wxPyEmptyString ;
38259 wxString *arg4 = (wxString *) &arg4_defvalue ;
38260 wxMenuItem *result = 0 ;
38261 void *argp1 = 0 ;
38262 int res1 = 0 ;
38263 int val2 ;
38264 int ecode2 = 0 ;
38265 bool temp3 = false ;
38266 bool temp4 = false ;
38267 PyObject * obj0 = 0 ;
38268 PyObject * obj1 = 0 ;
38269 PyObject * obj2 = 0 ;
38270 PyObject * obj3 = 0 ;
38271 char * kwnames[] = {
38272 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38273 };
38274
38275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38277 if (!SWIG_IsOK(res1)) {
38278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38279 }
38280 arg1 = reinterpret_cast< wxMenu * >(argp1);
38281 ecode2 = SWIG_AsVal_int(obj1, &val2);
38282 if (!SWIG_IsOK(ecode2)) {
38283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38284 }
38285 arg2 = static_cast< int >(val2);
38286 {
38287 arg3 = wxString_in_helper(obj2);
38288 if (arg3 == NULL) SWIG_fail;
38289 temp3 = true;
38290 }
38291 if (obj3) {
38292 {
38293 arg4 = wxString_in_helper(obj3);
38294 if (arg4 == NULL) SWIG_fail;
38295 temp4 = true;
38296 }
38297 }
38298 {
38299 PyThreadState* __tstate = wxPyBeginAllowThreads();
38300 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38301 wxPyEndAllowThreads(__tstate);
38302 if (PyErr_Occurred()) SWIG_fail;
38303 }
38304 {
38305 resultobj = wxPyMake_wxObject(result, (bool)0);
38306 }
38307 {
38308 if (temp3)
38309 delete arg3;
38310 }
38311 {
38312 if (temp4)
38313 delete arg4;
38314 }
38315 return resultobj;
38316 fail:
38317 {
38318 if (temp3)
38319 delete arg3;
38320 }
38321 {
38322 if (temp4)
38323 delete arg4;
38324 }
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj = 0;
38331 wxMenu *arg1 = (wxMenu *) 0 ;
38332 int arg2 ;
38333 wxString *arg3 = 0 ;
38334 wxMenu *arg4 = (wxMenu *) 0 ;
38335 wxString const &arg5_defvalue = wxPyEmptyString ;
38336 wxString *arg5 = (wxString *) &arg5_defvalue ;
38337 wxMenuItem *result = 0 ;
38338 void *argp1 = 0 ;
38339 int res1 = 0 ;
38340 int val2 ;
38341 int ecode2 = 0 ;
38342 bool temp3 = false ;
38343 void *argp4 = 0 ;
38344 int res4 = 0 ;
38345 bool temp5 = false ;
38346 PyObject * obj0 = 0 ;
38347 PyObject * obj1 = 0 ;
38348 PyObject * obj2 = 0 ;
38349 PyObject * obj3 = 0 ;
38350 PyObject * obj4 = 0 ;
38351 char * kwnames[] = {
38352 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38353 };
38354
38355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38357 if (!SWIG_IsOK(res1)) {
38358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38359 }
38360 arg1 = reinterpret_cast< wxMenu * >(argp1);
38361 ecode2 = SWIG_AsVal_int(obj1, &val2);
38362 if (!SWIG_IsOK(ecode2)) {
38363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38364 }
38365 arg2 = static_cast< int >(val2);
38366 {
38367 arg3 = wxString_in_helper(obj2);
38368 if (arg3 == NULL) SWIG_fail;
38369 temp3 = true;
38370 }
38371 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38372 if (!SWIG_IsOK(res4)) {
38373 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38374 }
38375 arg4 = reinterpret_cast< wxMenu * >(argp4);
38376 if (obj4) {
38377 {
38378 arg5 = wxString_in_helper(obj4);
38379 if (arg5 == NULL) SWIG_fail;
38380 temp5 = true;
38381 }
38382 }
38383 {
38384 PyThreadState* __tstate = wxPyBeginAllowThreads();
38385 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38386 wxPyEndAllowThreads(__tstate);
38387 if (PyErr_Occurred()) SWIG_fail;
38388 }
38389 {
38390 resultobj = wxPyMake_wxObject(result, (bool)0);
38391 }
38392 {
38393 if (temp3)
38394 delete arg3;
38395 }
38396 {
38397 if (temp5)
38398 delete arg5;
38399 }
38400 return resultobj;
38401 fail:
38402 {
38403 if (temp3)
38404 delete arg3;
38405 }
38406 {
38407 if (temp5)
38408 delete arg5;
38409 }
38410 return NULL;
38411 }
38412
38413
38414 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38415 PyObject *resultobj = 0;
38416 wxMenu *arg1 = (wxMenu *) 0 ;
38417 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38418 wxMenuItem *result = 0 ;
38419 void *argp1 = 0 ;
38420 int res1 = 0 ;
38421 int res2 = 0 ;
38422 PyObject * obj0 = 0 ;
38423 PyObject * obj1 = 0 ;
38424 char * kwnames[] = {
38425 (char *) "self",(char *) "item", NULL
38426 };
38427
38428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38430 if (!SWIG_IsOK(res1)) {
38431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38432 }
38433 arg1 = reinterpret_cast< wxMenu * >(argp1);
38434 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38435 if (!SWIG_IsOK(res2)) {
38436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38437 }
38438 {
38439 PyThreadState* __tstate = wxPyBeginAllowThreads();
38440 result = (wxMenuItem *)(arg1)->Append(arg2);
38441 wxPyEndAllowThreads(__tstate);
38442 if (PyErr_Occurred()) SWIG_fail;
38443 }
38444 {
38445 resultobj = wxPyMake_wxObject(result, (bool)0);
38446 }
38447 return resultobj;
38448 fail:
38449 return NULL;
38450 }
38451
38452
38453 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38454 PyObject *resultobj = 0;
38455 wxMenu *arg1 = (wxMenu *) 0 ;
38456 size_t arg2 ;
38457 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38458 wxMenuItem *result = 0 ;
38459 void *argp1 = 0 ;
38460 int res1 = 0 ;
38461 size_t val2 ;
38462 int ecode2 = 0 ;
38463 int res3 = 0 ;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 PyObject * obj2 = 0 ;
38467 char * kwnames[] = {
38468 (char *) "self",(char *) "pos",(char *) "item", NULL
38469 };
38470
38471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38473 if (!SWIG_IsOK(res1)) {
38474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38475 }
38476 arg1 = reinterpret_cast< wxMenu * >(argp1);
38477 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38478 if (!SWIG_IsOK(ecode2)) {
38479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38480 }
38481 arg2 = static_cast< size_t >(val2);
38482 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38483 if (!SWIG_IsOK(res3)) {
38484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38485 }
38486 {
38487 PyThreadState* __tstate = wxPyBeginAllowThreads();
38488 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38489 wxPyEndAllowThreads(__tstate);
38490 if (PyErr_Occurred()) SWIG_fail;
38491 }
38492 {
38493 resultobj = wxPyMake_wxObject(result, (bool)0);
38494 }
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj = 0;
38503 wxMenu *arg1 = (wxMenu *) 0 ;
38504 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38505 wxMenuItem *result = 0 ;
38506 void *argp1 = 0 ;
38507 int res1 = 0 ;
38508 int res2 = 0 ;
38509 PyObject * obj0 = 0 ;
38510 PyObject * obj1 = 0 ;
38511 char * kwnames[] = {
38512 (char *) "self",(char *) "item", NULL
38513 };
38514
38515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38517 if (!SWIG_IsOK(res1)) {
38518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38519 }
38520 arg1 = reinterpret_cast< wxMenu * >(argp1);
38521 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38522 if (!SWIG_IsOK(res2)) {
38523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38524 }
38525 {
38526 PyThreadState* __tstate = wxPyBeginAllowThreads();
38527 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38528 wxPyEndAllowThreads(__tstate);
38529 if (PyErr_Occurred()) SWIG_fail;
38530 }
38531 {
38532 resultobj = wxPyMake_wxObject(result, (bool)0);
38533 }
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38541 PyObject *resultobj = 0;
38542 wxMenu *arg1 = (wxMenu *) 0 ;
38543 void *argp1 = 0 ;
38544 int res1 = 0 ;
38545 PyObject *swig_obj[1] ;
38546
38547 if (!args) SWIG_fail;
38548 swig_obj[0] = args;
38549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38550 if (!SWIG_IsOK(res1)) {
38551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38552 }
38553 arg1 = reinterpret_cast< wxMenu * >(argp1);
38554 {
38555 PyThreadState* __tstate = wxPyBeginAllowThreads();
38556 (arg1)->Break();
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 resultobj = SWIG_Py_Void();
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38568 PyObject *resultobj = 0;
38569 wxMenu *arg1 = (wxMenu *) 0 ;
38570 size_t arg2 ;
38571 int arg3 ;
38572 wxString *arg4 = 0 ;
38573 wxString const &arg5_defvalue = wxPyEmptyString ;
38574 wxString *arg5 = (wxString *) &arg5_defvalue ;
38575 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38576 wxMenuItem *result = 0 ;
38577 void *argp1 = 0 ;
38578 int res1 = 0 ;
38579 size_t val2 ;
38580 int ecode2 = 0 ;
38581 int val3 ;
38582 int ecode3 = 0 ;
38583 bool temp4 = false ;
38584 bool temp5 = false ;
38585 int val6 ;
38586 int ecode6 = 0 ;
38587 PyObject * obj0 = 0 ;
38588 PyObject * obj1 = 0 ;
38589 PyObject * obj2 = 0 ;
38590 PyObject * obj3 = 0 ;
38591 PyObject * obj4 = 0 ;
38592 PyObject * obj5 = 0 ;
38593 char * kwnames[] = {
38594 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38595 };
38596
38597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38599 if (!SWIG_IsOK(res1)) {
38600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38601 }
38602 arg1 = reinterpret_cast< wxMenu * >(argp1);
38603 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38604 if (!SWIG_IsOK(ecode2)) {
38605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38606 }
38607 arg2 = static_cast< size_t >(val2);
38608 ecode3 = SWIG_AsVal_int(obj2, &val3);
38609 if (!SWIG_IsOK(ecode3)) {
38610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38611 }
38612 arg3 = static_cast< int >(val3);
38613 {
38614 arg4 = wxString_in_helper(obj3);
38615 if (arg4 == NULL) SWIG_fail;
38616 temp4 = true;
38617 }
38618 if (obj4) {
38619 {
38620 arg5 = wxString_in_helper(obj4);
38621 if (arg5 == NULL) SWIG_fail;
38622 temp5 = true;
38623 }
38624 }
38625 if (obj5) {
38626 ecode6 = SWIG_AsVal_int(obj5, &val6);
38627 if (!SWIG_IsOK(ecode6)) {
38628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38629 }
38630 arg6 = static_cast< wxItemKind >(val6);
38631 }
38632 {
38633 PyThreadState* __tstate = wxPyBeginAllowThreads();
38634 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38635 wxPyEndAllowThreads(__tstate);
38636 if (PyErr_Occurred()) SWIG_fail;
38637 }
38638 {
38639 resultobj = wxPyMake_wxObject(result, (bool)0);
38640 }
38641 {
38642 if (temp4)
38643 delete arg4;
38644 }
38645 {
38646 if (temp5)
38647 delete arg5;
38648 }
38649 return resultobj;
38650 fail:
38651 {
38652 if (temp4)
38653 delete arg4;
38654 }
38655 {
38656 if (temp5)
38657 delete arg5;
38658 }
38659 return NULL;
38660 }
38661
38662
38663 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38664 PyObject *resultobj = 0;
38665 wxMenu *arg1 = (wxMenu *) 0 ;
38666 size_t arg2 ;
38667 wxMenuItem *result = 0 ;
38668 void *argp1 = 0 ;
38669 int res1 = 0 ;
38670 size_t val2 ;
38671 int ecode2 = 0 ;
38672 PyObject * obj0 = 0 ;
38673 PyObject * obj1 = 0 ;
38674 char * kwnames[] = {
38675 (char *) "self",(char *) "pos", NULL
38676 };
38677
38678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38680 if (!SWIG_IsOK(res1)) {
38681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38682 }
38683 arg1 = reinterpret_cast< wxMenu * >(argp1);
38684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38685 if (!SWIG_IsOK(ecode2)) {
38686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38687 }
38688 arg2 = static_cast< size_t >(val2);
38689 {
38690 PyThreadState* __tstate = wxPyBeginAllowThreads();
38691 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38692 wxPyEndAllowThreads(__tstate);
38693 if (PyErr_Occurred()) SWIG_fail;
38694 }
38695 {
38696 resultobj = wxPyMake_wxObject(result, (bool)0);
38697 }
38698 return resultobj;
38699 fail:
38700 return NULL;
38701 }
38702
38703
38704 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38705 PyObject *resultobj = 0;
38706 wxMenu *arg1 = (wxMenu *) 0 ;
38707 size_t arg2 ;
38708 int arg3 ;
38709 wxString *arg4 = 0 ;
38710 wxString const &arg5_defvalue = wxPyEmptyString ;
38711 wxString *arg5 = (wxString *) &arg5_defvalue ;
38712 wxMenuItem *result = 0 ;
38713 void *argp1 = 0 ;
38714 int res1 = 0 ;
38715 size_t val2 ;
38716 int ecode2 = 0 ;
38717 int val3 ;
38718 int ecode3 = 0 ;
38719 bool temp4 = false ;
38720 bool temp5 = false ;
38721 PyObject * obj0 = 0 ;
38722 PyObject * obj1 = 0 ;
38723 PyObject * obj2 = 0 ;
38724 PyObject * obj3 = 0 ;
38725 PyObject * obj4 = 0 ;
38726 char * kwnames[] = {
38727 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38728 };
38729
38730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38732 if (!SWIG_IsOK(res1)) {
38733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38734 }
38735 arg1 = reinterpret_cast< wxMenu * >(argp1);
38736 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38737 if (!SWIG_IsOK(ecode2)) {
38738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38739 }
38740 arg2 = static_cast< size_t >(val2);
38741 ecode3 = SWIG_AsVal_int(obj2, &val3);
38742 if (!SWIG_IsOK(ecode3)) {
38743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38744 }
38745 arg3 = static_cast< int >(val3);
38746 {
38747 arg4 = wxString_in_helper(obj3);
38748 if (arg4 == NULL) SWIG_fail;
38749 temp4 = true;
38750 }
38751 if (obj4) {
38752 {
38753 arg5 = wxString_in_helper(obj4);
38754 if (arg5 == NULL) SWIG_fail;
38755 temp5 = true;
38756 }
38757 }
38758 {
38759 PyThreadState* __tstate = wxPyBeginAllowThreads();
38760 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38761 wxPyEndAllowThreads(__tstate);
38762 if (PyErr_Occurred()) SWIG_fail;
38763 }
38764 {
38765 resultobj = wxPyMake_wxObject(result, (bool)0);
38766 }
38767 {
38768 if (temp4)
38769 delete arg4;
38770 }
38771 {
38772 if (temp5)
38773 delete arg5;
38774 }
38775 return resultobj;
38776 fail:
38777 {
38778 if (temp4)
38779 delete arg4;
38780 }
38781 {
38782 if (temp5)
38783 delete arg5;
38784 }
38785 return NULL;
38786 }
38787
38788
38789 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38790 PyObject *resultobj = 0;
38791 wxMenu *arg1 = (wxMenu *) 0 ;
38792 size_t arg2 ;
38793 int arg3 ;
38794 wxString *arg4 = 0 ;
38795 wxString const &arg5_defvalue = wxPyEmptyString ;
38796 wxString *arg5 = (wxString *) &arg5_defvalue ;
38797 wxMenuItem *result = 0 ;
38798 void *argp1 = 0 ;
38799 int res1 = 0 ;
38800 size_t val2 ;
38801 int ecode2 = 0 ;
38802 int val3 ;
38803 int ecode3 = 0 ;
38804 bool temp4 = false ;
38805 bool temp5 = false ;
38806 PyObject * obj0 = 0 ;
38807 PyObject * obj1 = 0 ;
38808 PyObject * obj2 = 0 ;
38809 PyObject * obj3 = 0 ;
38810 PyObject * obj4 = 0 ;
38811 char * kwnames[] = {
38812 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38813 };
38814
38815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38817 if (!SWIG_IsOK(res1)) {
38818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38819 }
38820 arg1 = reinterpret_cast< wxMenu * >(argp1);
38821 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38822 if (!SWIG_IsOK(ecode2)) {
38823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38824 }
38825 arg2 = static_cast< size_t >(val2);
38826 ecode3 = SWIG_AsVal_int(obj2, &val3);
38827 if (!SWIG_IsOK(ecode3)) {
38828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38829 }
38830 arg3 = static_cast< int >(val3);
38831 {
38832 arg4 = wxString_in_helper(obj3);
38833 if (arg4 == NULL) SWIG_fail;
38834 temp4 = true;
38835 }
38836 if (obj4) {
38837 {
38838 arg5 = wxString_in_helper(obj4);
38839 if (arg5 == NULL) SWIG_fail;
38840 temp5 = true;
38841 }
38842 }
38843 {
38844 PyThreadState* __tstate = wxPyBeginAllowThreads();
38845 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38846 wxPyEndAllowThreads(__tstate);
38847 if (PyErr_Occurred()) SWIG_fail;
38848 }
38849 {
38850 resultobj = wxPyMake_wxObject(result, (bool)0);
38851 }
38852 {
38853 if (temp4)
38854 delete arg4;
38855 }
38856 {
38857 if (temp5)
38858 delete arg5;
38859 }
38860 return resultobj;
38861 fail:
38862 {
38863 if (temp4)
38864 delete arg4;
38865 }
38866 {
38867 if (temp5)
38868 delete arg5;
38869 }
38870 return NULL;
38871 }
38872
38873
38874 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38875 PyObject *resultobj = 0;
38876 wxMenu *arg1 = (wxMenu *) 0 ;
38877 size_t arg2 ;
38878 int arg3 ;
38879 wxString *arg4 = 0 ;
38880 wxMenu *arg5 = (wxMenu *) 0 ;
38881 wxString const &arg6_defvalue = wxPyEmptyString ;
38882 wxString *arg6 = (wxString *) &arg6_defvalue ;
38883 wxMenuItem *result = 0 ;
38884 void *argp1 = 0 ;
38885 int res1 = 0 ;
38886 size_t val2 ;
38887 int ecode2 = 0 ;
38888 int val3 ;
38889 int ecode3 = 0 ;
38890 bool temp4 = false ;
38891 void *argp5 = 0 ;
38892 int res5 = 0 ;
38893 bool temp6 = false ;
38894 PyObject * obj0 = 0 ;
38895 PyObject * obj1 = 0 ;
38896 PyObject * obj2 = 0 ;
38897 PyObject * obj3 = 0 ;
38898 PyObject * obj4 = 0 ;
38899 PyObject * obj5 = 0 ;
38900 char * kwnames[] = {
38901 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38902 };
38903
38904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38906 if (!SWIG_IsOK(res1)) {
38907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38908 }
38909 arg1 = reinterpret_cast< wxMenu * >(argp1);
38910 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38911 if (!SWIG_IsOK(ecode2)) {
38912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38913 }
38914 arg2 = static_cast< size_t >(val2);
38915 ecode3 = SWIG_AsVal_int(obj2, &val3);
38916 if (!SWIG_IsOK(ecode3)) {
38917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38918 }
38919 arg3 = static_cast< int >(val3);
38920 {
38921 arg4 = wxString_in_helper(obj3);
38922 if (arg4 == NULL) SWIG_fail;
38923 temp4 = true;
38924 }
38925 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38926 if (!SWIG_IsOK(res5)) {
38927 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38928 }
38929 arg5 = reinterpret_cast< wxMenu * >(argp5);
38930 if (obj5) {
38931 {
38932 arg6 = wxString_in_helper(obj5);
38933 if (arg6 == NULL) SWIG_fail;
38934 temp6 = true;
38935 }
38936 }
38937 {
38938 PyThreadState* __tstate = wxPyBeginAllowThreads();
38939 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38940 wxPyEndAllowThreads(__tstate);
38941 if (PyErr_Occurred()) SWIG_fail;
38942 }
38943 {
38944 resultobj = wxPyMake_wxObject(result, (bool)0);
38945 }
38946 {
38947 if (temp4)
38948 delete arg4;
38949 }
38950 {
38951 if (temp6)
38952 delete arg6;
38953 }
38954 return resultobj;
38955 fail:
38956 {
38957 if (temp4)
38958 delete arg4;
38959 }
38960 {
38961 if (temp6)
38962 delete arg6;
38963 }
38964 return NULL;
38965 }
38966
38967
38968 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38969 PyObject *resultobj = 0;
38970 wxMenu *arg1 = (wxMenu *) 0 ;
38971 int arg2 ;
38972 wxString *arg3 = 0 ;
38973 wxString const &arg4_defvalue = wxPyEmptyString ;
38974 wxString *arg4 = (wxString *) &arg4_defvalue ;
38975 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38976 wxMenuItem *result = 0 ;
38977 void *argp1 = 0 ;
38978 int res1 = 0 ;
38979 int val2 ;
38980 int ecode2 = 0 ;
38981 bool temp3 = false ;
38982 bool temp4 = false ;
38983 int val5 ;
38984 int ecode5 = 0 ;
38985 PyObject * obj0 = 0 ;
38986 PyObject * obj1 = 0 ;
38987 PyObject * obj2 = 0 ;
38988 PyObject * obj3 = 0 ;
38989 PyObject * obj4 = 0 ;
38990 char * kwnames[] = {
38991 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38992 };
38993
38994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38996 if (!SWIG_IsOK(res1)) {
38997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38998 }
38999 arg1 = reinterpret_cast< wxMenu * >(argp1);
39000 ecode2 = SWIG_AsVal_int(obj1, &val2);
39001 if (!SWIG_IsOK(ecode2)) {
39002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39003 }
39004 arg2 = static_cast< int >(val2);
39005 {
39006 arg3 = wxString_in_helper(obj2);
39007 if (arg3 == NULL) SWIG_fail;
39008 temp3 = true;
39009 }
39010 if (obj3) {
39011 {
39012 arg4 = wxString_in_helper(obj3);
39013 if (arg4 == NULL) SWIG_fail;
39014 temp4 = true;
39015 }
39016 }
39017 if (obj4) {
39018 ecode5 = SWIG_AsVal_int(obj4, &val5);
39019 if (!SWIG_IsOK(ecode5)) {
39020 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39021 }
39022 arg5 = static_cast< wxItemKind >(val5);
39023 }
39024 {
39025 PyThreadState* __tstate = wxPyBeginAllowThreads();
39026 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39027 wxPyEndAllowThreads(__tstate);
39028 if (PyErr_Occurred()) SWIG_fail;
39029 }
39030 {
39031 resultobj = wxPyMake_wxObject(result, (bool)0);
39032 }
39033 {
39034 if (temp3)
39035 delete arg3;
39036 }
39037 {
39038 if (temp4)
39039 delete arg4;
39040 }
39041 return resultobj;
39042 fail:
39043 {
39044 if (temp3)
39045 delete arg3;
39046 }
39047 {
39048 if (temp4)
39049 delete arg4;
39050 }
39051 return NULL;
39052 }
39053
39054
39055 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39056 PyObject *resultobj = 0;
39057 wxMenu *arg1 = (wxMenu *) 0 ;
39058 wxMenuItem *result = 0 ;
39059 void *argp1 = 0 ;
39060 int res1 = 0 ;
39061 PyObject *swig_obj[1] ;
39062
39063 if (!args) SWIG_fail;
39064 swig_obj[0] = args;
39065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39066 if (!SWIG_IsOK(res1)) {
39067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39068 }
39069 arg1 = reinterpret_cast< wxMenu * >(argp1);
39070 {
39071 PyThreadState* __tstate = wxPyBeginAllowThreads();
39072 result = (wxMenuItem *)(arg1)->PrependSeparator();
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 {
39077 resultobj = wxPyMake_wxObject(result, (bool)0);
39078 }
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj = 0;
39087 wxMenu *arg1 = (wxMenu *) 0 ;
39088 int arg2 ;
39089 wxString *arg3 = 0 ;
39090 wxString const &arg4_defvalue = wxPyEmptyString ;
39091 wxString *arg4 = (wxString *) &arg4_defvalue ;
39092 wxMenuItem *result = 0 ;
39093 void *argp1 = 0 ;
39094 int res1 = 0 ;
39095 int val2 ;
39096 int ecode2 = 0 ;
39097 bool temp3 = false ;
39098 bool temp4 = false ;
39099 PyObject * obj0 = 0 ;
39100 PyObject * obj1 = 0 ;
39101 PyObject * obj2 = 0 ;
39102 PyObject * obj3 = 0 ;
39103 char * kwnames[] = {
39104 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39105 };
39106
39107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39109 if (!SWIG_IsOK(res1)) {
39110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39111 }
39112 arg1 = reinterpret_cast< wxMenu * >(argp1);
39113 ecode2 = SWIG_AsVal_int(obj1, &val2);
39114 if (!SWIG_IsOK(ecode2)) {
39115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39116 }
39117 arg2 = static_cast< int >(val2);
39118 {
39119 arg3 = wxString_in_helper(obj2);
39120 if (arg3 == NULL) SWIG_fail;
39121 temp3 = true;
39122 }
39123 if (obj3) {
39124 {
39125 arg4 = wxString_in_helper(obj3);
39126 if (arg4 == NULL) SWIG_fail;
39127 temp4 = true;
39128 }
39129 }
39130 {
39131 PyThreadState* __tstate = wxPyBeginAllowThreads();
39132 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39133 wxPyEndAllowThreads(__tstate);
39134 if (PyErr_Occurred()) SWIG_fail;
39135 }
39136 {
39137 resultobj = wxPyMake_wxObject(result, (bool)0);
39138 }
39139 {
39140 if (temp3)
39141 delete arg3;
39142 }
39143 {
39144 if (temp4)
39145 delete arg4;
39146 }
39147 return resultobj;
39148 fail:
39149 {
39150 if (temp3)
39151 delete arg3;
39152 }
39153 {
39154 if (temp4)
39155 delete arg4;
39156 }
39157 return NULL;
39158 }
39159
39160
39161 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39162 PyObject *resultobj = 0;
39163 wxMenu *arg1 = (wxMenu *) 0 ;
39164 int arg2 ;
39165 wxString *arg3 = 0 ;
39166 wxString const &arg4_defvalue = wxPyEmptyString ;
39167 wxString *arg4 = (wxString *) &arg4_defvalue ;
39168 wxMenuItem *result = 0 ;
39169 void *argp1 = 0 ;
39170 int res1 = 0 ;
39171 int val2 ;
39172 int ecode2 = 0 ;
39173 bool temp3 = false ;
39174 bool temp4 = false ;
39175 PyObject * obj0 = 0 ;
39176 PyObject * obj1 = 0 ;
39177 PyObject * obj2 = 0 ;
39178 PyObject * obj3 = 0 ;
39179 char * kwnames[] = {
39180 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39181 };
39182
39183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39185 if (!SWIG_IsOK(res1)) {
39186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39187 }
39188 arg1 = reinterpret_cast< wxMenu * >(argp1);
39189 ecode2 = SWIG_AsVal_int(obj1, &val2);
39190 if (!SWIG_IsOK(ecode2)) {
39191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39192 }
39193 arg2 = static_cast< int >(val2);
39194 {
39195 arg3 = wxString_in_helper(obj2);
39196 if (arg3 == NULL) SWIG_fail;
39197 temp3 = true;
39198 }
39199 if (obj3) {
39200 {
39201 arg4 = wxString_in_helper(obj3);
39202 if (arg4 == NULL) SWIG_fail;
39203 temp4 = true;
39204 }
39205 }
39206 {
39207 PyThreadState* __tstate = wxPyBeginAllowThreads();
39208 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39209 wxPyEndAllowThreads(__tstate);
39210 if (PyErr_Occurred()) SWIG_fail;
39211 }
39212 {
39213 resultobj = wxPyMake_wxObject(result, (bool)0);
39214 }
39215 {
39216 if (temp3)
39217 delete arg3;
39218 }
39219 {
39220 if (temp4)
39221 delete arg4;
39222 }
39223 return resultobj;
39224 fail:
39225 {
39226 if (temp3)
39227 delete arg3;
39228 }
39229 {
39230 if (temp4)
39231 delete arg4;
39232 }
39233 return NULL;
39234 }
39235
39236
39237 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj = 0;
39239 wxMenu *arg1 = (wxMenu *) 0 ;
39240 int arg2 ;
39241 wxString *arg3 = 0 ;
39242 wxMenu *arg4 = (wxMenu *) 0 ;
39243 wxString const &arg5_defvalue = wxPyEmptyString ;
39244 wxString *arg5 = (wxString *) &arg5_defvalue ;
39245 wxMenuItem *result = 0 ;
39246 void *argp1 = 0 ;
39247 int res1 = 0 ;
39248 int val2 ;
39249 int ecode2 = 0 ;
39250 bool temp3 = false ;
39251 void *argp4 = 0 ;
39252 int res4 = 0 ;
39253 bool temp5 = false ;
39254 PyObject * obj0 = 0 ;
39255 PyObject * obj1 = 0 ;
39256 PyObject * obj2 = 0 ;
39257 PyObject * obj3 = 0 ;
39258 PyObject * obj4 = 0 ;
39259 char * kwnames[] = {
39260 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39261 };
39262
39263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39265 if (!SWIG_IsOK(res1)) {
39266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39267 }
39268 arg1 = reinterpret_cast< wxMenu * >(argp1);
39269 ecode2 = SWIG_AsVal_int(obj1, &val2);
39270 if (!SWIG_IsOK(ecode2)) {
39271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39272 }
39273 arg2 = static_cast< int >(val2);
39274 {
39275 arg3 = wxString_in_helper(obj2);
39276 if (arg3 == NULL) SWIG_fail;
39277 temp3 = true;
39278 }
39279 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39280 if (!SWIG_IsOK(res4)) {
39281 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39282 }
39283 arg4 = reinterpret_cast< wxMenu * >(argp4);
39284 if (obj4) {
39285 {
39286 arg5 = wxString_in_helper(obj4);
39287 if (arg5 == NULL) SWIG_fail;
39288 temp5 = true;
39289 }
39290 }
39291 {
39292 PyThreadState* __tstate = wxPyBeginAllowThreads();
39293 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39294 wxPyEndAllowThreads(__tstate);
39295 if (PyErr_Occurred()) SWIG_fail;
39296 }
39297 {
39298 resultobj = wxPyMake_wxObject(result, (bool)0);
39299 }
39300 {
39301 if (temp3)
39302 delete arg3;
39303 }
39304 {
39305 if (temp5)
39306 delete arg5;
39307 }
39308 return resultobj;
39309 fail:
39310 {
39311 if (temp3)
39312 delete arg3;
39313 }
39314 {
39315 if (temp5)
39316 delete arg5;
39317 }
39318 return NULL;
39319 }
39320
39321
39322 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39323 PyObject *resultobj = 0;
39324 wxMenu *arg1 = (wxMenu *) 0 ;
39325 int arg2 ;
39326 wxMenuItem *result = 0 ;
39327 void *argp1 = 0 ;
39328 int res1 = 0 ;
39329 int val2 ;
39330 int ecode2 = 0 ;
39331 PyObject * obj0 = 0 ;
39332 PyObject * obj1 = 0 ;
39333 char * kwnames[] = {
39334 (char *) "self",(char *) "id", NULL
39335 };
39336
39337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39339 if (!SWIG_IsOK(res1)) {
39340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39341 }
39342 arg1 = reinterpret_cast< wxMenu * >(argp1);
39343 ecode2 = SWIG_AsVal_int(obj1, &val2);
39344 if (!SWIG_IsOK(ecode2)) {
39345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39346 }
39347 arg2 = static_cast< int >(val2);
39348 {
39349 PyThreadState* __tstate = wxPyBeginAllowThreads();
39350 result = (wxMenuItem *)(arg1)->Remove(arg2);
39351 wxPyEndAllowThreads(__tstate);
39352 if (PyErr_Occurred()) SWIG_fail;
39353 }
39354 {
39355 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39356 }
39357 return resultobj;
39358 fail:
39359 return NULL;
39360 }
39361
39362
39363 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39364 PyObject *resultobj = 0;
39365 wxMenu *arg1 = (wxMenu *) 0 ;
39366 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39367 wxMenuItem *result = 0 ;
39368 void *argp1 = 0 ;
39369 int res1 = 0 ;
39370 void *argp2 = 0 ;
39371 int res2 = 0 ;
39372 PyObject * obj0 = 0 ;
39373 PyObject * obj1 = 0 ;
39374 char * kwnames[] = {
39375 (char *) "self",(char *) "item", NULL
39376 };
39377
39378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39380 if (!SWIG_IsOK(res1)) {
39381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39382 }
39383 arg1 = reinterpret_cast< wxMenu * >(argp1);
39384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39385 if (!SWIG_IsOK(res2)) {
39386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39387 }
39388 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39389 {
39390 PyThreadState* __tstate = wxPyBeginAllowThreads();
39391 result = (wxMenuItem *)(arg1)->Remove(arg2);
39392 wxPyEndAllowThreads(__tstate);
39393 if (PyErr_Occurred()) SWIG_fail;
39394 }
39395 {
39396 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39397 }
39398 return resultobj;
39399 fail:
39400 return NULL;
39401 }
39402
39403
39404 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39405 PyObject *resultobj = 0;
39406 wxMenu *arg1 = (wxMenu *) 0 ;
39407 int arg2 ;
39408 bool result;
39409 void *argp1 = 0 ;
39410 int res1 = 0 ;
39411 int val2 ;
39412 int ecode2 = 0 ;
39413 PyObject * obj0 = 0 ;
39414 PyObject * obj1 = 0 ;
39415 char * kwnames[] = {
39416 (char *) "self",(char *) "id", NULL
39417 };
39418
39419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39421 if (!SWIG_IsOK(res1)) {
39422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39423 }
39424 arg1 = reinterpret_cast< wxMenu * >(argp1);
39425 ecode2 = SWIG_AsVal_int(obj1, &val2);
39426 if (!SWIG_IsOK(ecode2)) {
39427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39428 }
39429 arg2 = static_cast< int >(val2);
39430 {
39431 PyThreadState* __tstate = wxPyBeginAllowThreads();
39432 result = (bool)(arg1)->Delete(arg2);
39433 wxPyEndAllowThreads(__tstate);
39434 if (PyErr_Occurred()) SWIG_fail;
39435 }
39436 {
39437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39438 }
39439 return resultobj;
39440 fail:
39441 return NULL;
39442 }
39443
39444
39445 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39446 PyObject *resultobj = 0;
39447 wxMenu *arg1 = (wxMenu *) 0 ;
39448 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39449 bool result;
39450 void *argp1 = 0 ;
39451 int res1 = 0 ;
39452 void *argp2 = 0 ;
39453 int res2 = 0 ;
39454 PyObject * obj0 = 0 ;
39455 PyObject * obj1 = 0 ;
39456 char * kwnames[] = {
39457 (char *) "self",(char *) "item", NULL
39458 };
39459
39460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39462 if (!SWIG_IsOK(res1)) {
39463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39464 }
39465 arg1 = reinterpret_cast< wxMenu * >(argp1);
39466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39467 if (!SWIG_IsOK(res2)) {
39468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39469 }
39470 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39471 {
39472 PyThreadState* __tstate = wxPyBeginAllowThreads();
39473 result = (bool)(arg1)->Delete(arg2);
39474 wxPyEndAllowThreads(__tstate);
39475 if (PyErr_Occurred()) SWIG_fail;
39476 }
39477 {
39478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39479 }
39480 return resultobj;
39481 fail:
39482 return NULL;
39483 }
39484
39485
39486 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39487 PyObject *resultobj = 0;
39488 wxMenu *arg1 = (wxMenu *) 0 ;
39489 void *argp1 = 0 ;
39490 int res1 = 0 ;
39491 PyObject *swig_obj[1] ;
39492
39493 if (!args) SWIG_fail;
39494 swig_obj[0] = args;
39495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39496 if (!SWIG_IsOK(res1)) {
39497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39498 }
39499 arg1 = reinterpret_cast< wxMenu * >(argp1);
39500 {
39501 PyThreadState* __tstate = wxPyBeginAllowThreads();
39502 wxMenu_Destroy(arg1);
39503 wxPyEndAllowThreads(__tstate);
39504 if (PyErr_Occurred()) SWIG_fail;
39505 }
39506 resultobj = SWIG_Py_Void();
39507 return resultobj;
39508 fail:
39509 return NULL;
39510 }
39511
39512
39513 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39514 PyObject *resultobj = 0;
39515 wxMenu *arg1 = (wxMenu *) 0 ;
39516 int arg2 ;
39517 bool result;
39518 void *argp1 = 0 ;
39519 int res1 = 0 ;
39520 int val2 ;
39521 int ecode2 = 0 ;
39522 PyObject * obj0 = 0 ;
39523 PyObject * obj1 = 0 ;
39524 char * kwnames[] = {
39525 (char *) "self",(char *) "id", NULL
39526 };
39527
39528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39530 if (!SWIG_IsOK(res1)) {
39531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39532 }
39533 arg1 = reinterpret_cast< wxMenu * >(argp1);
39534 ecode2 = SWIG_AsVal_int(obj1, &val2);
39535 if (!SWIG_IsOK(ecode2)) {
39536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39537 }
39538 arg2 = static_cast< int >(val2);
39539 {
39540 PyThreadState* __tstate = wxPyBeginAllowThreads();
39541 result = (bool)(arg1)->Destroy(arg2);
39542 wxPyEndAllowThreads(__tstate);
39543 if (PyErr_Occurred()) SWIG_fail;
39544 }
39545 {
39546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39547 }
39548 return resultobj;
39549 fail:
39550 return NULL;
39551 }
39552
39553
39554 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39555 PyObject *resultobj = 0;
39556 wxMenu *arg1 = (wxMenu *) 0 ;
39557 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39558 bool result;
39559 void *argp1 = 0 ;
39560 int res1 = 0 ;
39561 void *argp2 = 0 ;
39562 int res2 = 0 ;
39563 PyObject * obj0 = 0 ;
39564 PyObject * obj1 = 0 ;
39565 char * kwnames[] = {
39566 (char *) "self",(char *) "item", NULL
39567 };
39568
39569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39571 if (!SWIG_IsOK(res1)) {
39572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39573 }
39574 arg1 = reinterpret_cast< wxMenu * >(argp1);
39575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39576 if (!SWIG_IsOK(res2)) {
39577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39578 }
39579 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 result = (bool)(arg1)->Destroy(arg2);
39583 wxPyEndAllowThreads(__tstate);
39584 if (PyErr_Occurred()) SWIG_fail;
39585 }
39586 {
39587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39588 }
39589 return resultobj;
39590 fail:
39591 return NULL;
39592 }
39593
39594
39595 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39596 PyObject *resultobj = 0;
39597 wxMenu *arg1 = (wxMenu *) 0 ;
39598 size_t result;
39599 void *argp1 = 0 ;
39600 int res1 = 0 ;
39601 PyObject *swig_obj[1] ;
39602
39603 if (!args) SWIG_fail;
39604 swig_obj[0] = args;
39605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39606 if (!SWIG_IsOK(res1)) {
39607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39608 }
39609 arg1 = reinterpret_cast< wxMenu * >(argp1);
39610 {
39611 PyThreadState* __tstate = wxPyBeginAllowThreads();
39612 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39613 wxPyEndAllowThreads(__tstate);
39614 if (PyErr_Occurred()) SWIG_fail;
39615 }
39616 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39617 return resultobj;
39618 fail:
39619 return NULL;
39620 }
39621
39622
39623 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39624 PyObject *resultobj = 0;
39625 wxMenu *arg1 = (wxMenu *) 0 ;
39626 PyObject *result = 0 ;
39627 void *argp1 = 0 ;
39628 int res1 = 0 ;
39629 PyObject *swig_obj[1] ;
39630
39631 if (!args) SWIG_fail;
39632 swig_obj[0] = args;
39633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39634 if (!SWIG_IsOK(res1)) {
39635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39636 }
39637 arg1 = reinterpret_cast< wxMenu * >(argp1);
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39641 wxPyEndAllowThreads(__tstate);
39642 if (PyErr_Occurred()) SWIG_fail;
39643 }
39644 resultobj = result;
39645 return resultobj;
39646 fail:
39647 return NULL;
39648 }
39649
39650
39651 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39652 PyObject *resultobj = 0;
39653 wxMenu *arg1 = (wxMenu *) 0 ;
39654 wxString *arg2 = 0 ;
39655 int result;
39656 void *argp1 = 0 ;
39657 int res1 = 0 ;
39658 bool temp2 = false ;
39659 PyObject * obj0 = 0 ;
39660 PyObject * obj1 = 0 ;
39661 char * kwnames[] = {
39662 (char *) "self",(char *) "item", NULL
39663 };
39664
39665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39667 if (!SWIG_IsOK(res1)) {
39668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39669 }
39670 arg1 = reinterpret_cast< wxMenu * >(argp1);
39671 {
39672 arg2 = wxString_in_helper(obj1);
39673 if (arg2 == NULL) SWIG_fail;
39674 temp2 = true;
39675 }
39676 {
39677 PyThreadState* __tstate = wxPyBeginAllowThreads();
39678 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39679 wxPyEndAllowThreads(__tstate);
39680 if (PyErr_Occurred()) SWIG_fail;
39681 }
39682 resultobj = SWIG_From_int(static_cast< int >(result));
39683 {
39684 if (temp2)
39685 delete arg2;
39686 }
39687 return resultobj;
39688 fail:
39689 {
39690 if (temp2)
39691 delete arg2;
39692 }
39693 return NULL;
39694 }
39695
39696
39697 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj = 0;
39699 wxMenu *arg1 = (wxMenu *) 0 ;
39700 int arg2 ;
39701 wxMenuItem *result = 0 ;
39702 void *argp1 = 0 ;
39703 int res1 = 0 ;
39704 int val2 ;
39705 int ecode2 = 0 ;
39706 PyObject * obj0 = 0 ;
39707 PyObject * obj1 = 0 ;
39708 char * kwnames[] = {
39709 (char *) "self",(char *) "id", NULL
39710 };
39711
39712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39714 if (!SWIG_IsOK(res1)) {
39715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39716 }
39717 arg1 = reinterpret_cast< wxMenu * >(argp1);
39718 ecode2 = SWIG_AsVal_int(obj1, &val2);
39719 if (!SWIG_IsOK(ecode2)) {
39720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39721 }
39722 arg2 = static_cast< int >(val2);
39723 {
39724 PyThreadState* __tstate = wxPyBeginAllowThreads();
39725 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39726 wxPyEndAllowThreads(__tstate);
39727 if (PyErr_Occurred()) SWIG_fail;
39728 }
39729 {
39730 resultobj = wxPyMake_wxObject(result, (bool)0);
39731 }
39732 return resultobj;
39733 fail:
39734 return NULL;
39735 }
39736
39737
39738 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj = 0;
39740 wxMenu *arg1 = (wxMenu *) 0 ;
39741 size_t arg2 ;
39742 wxMenuItem *result = 0 ;
39743 void *argp1 = 0 ;
39744 int res1 = 0 ;
39745 size_t val2 ;
39746 int ecode2 = 0 ;
39747 PyObject * obj0 = 0 ;
39748 PyObject * obj1 = 0 ;
39749 char * kwnames[] = {
39750 (char *) "self",(char *) "position", NULL
39751 };
39752
39753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39755 if (!SWIG_IsOK(res1)) {
39756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39757 }
39758 arg1 = reinterpret_cast< wxMenu * >(argp1);
39759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39760 if (!SWIG_IsOK(ecode2)) {
39761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39762 }
39763 arg2 = static_cast< size_t >(val2);
39764 {
39765 PyThreadState* __tstate = wxPyBeginAllowThreads();
39766 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39767 wxPyEndAllowThreads(__tstate);
39768 if (PyErr_Occurred()) SWIG_fail;
39769 }
39770 {
39771 resultobj = wxPyMake_wxObject(result, (bool)0);
39772 }
39773 return resultobj;
39774 fail:
39775 return NULL;
39776 }
39777
39778
39779 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39780 PyObject *resultobj = 0;
39781 wxMenu *arg1 = (wxMenu *) 0 ;
39782 int arg2 ;
39783 bool arg3 ;
39784 void *argp1 = 0 ;
39785 int res1 = 0 ;
39786 int val2 ;
39787 int ecode2 = 0 ;
39788 bool val3 ;
39789 int ecode3 = 0 ;
39790 PyObject * obj0 = 0 ;
39791 PyObject * obj1 = 0 ;
39792 PyObject * obj2 = 0 ;
39793 char * kwnames[] = {
39794 (char *) "self",(char *) "id",(char *) "enable", NULL
39795 };
39796
39797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39799 if (!SWIG_IsOK(res1)) {
39800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39801 }
39802 arg1 = reinterpret_cast< wxMenu * >(argp1);
39803 ecode2 = SWIG_AsVal_int(obj1, &val2);
39804 if (!SWIG_IsOK(ecode2)) {
39805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39806 }
39807 arg2 = static_cast< int >(val2);
39808 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39809 if (!SWIG_IsOK(ecode3)) {
39810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39811 }
39812 arg3 = static_cast< bool >(val3);
39813 {
39814 PyThreadState* __tstate = wxPyBeginAllowThreads();
39815 (arg1)->Enable(arg2,arg3);
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 resultobj = SWIG_Py_Void();
39820 return resultobj;
39821 fail:
39822 return NULL;
39823 }
39824
39825
39826 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39827 PyObject *resultobj = 0;
39828 wxMenu *arg1 = (wxMenu *) 0 ;
39829 int arg2 ;
39830 bool result;
39831 void *argp1 = 0 ;
39832 int res1 = 0 ;
39833 int val2 ;
39834 int ecode2 = 0 ;
39835 PyObject * obj0 = 0 ;
39836 PyObject * obj1 = 0 ;
39837 char * kwnames[] = {
39838 (char *) "self",(char *) "id", NULL
39839 };
39840
39841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39843 if (!SWIG_IsOK(res1)) {
39844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39845 }
39846 arg1 = reinterpret_cast< wxMenu * >(argp1);
39847 ecode2 = SWIG_AsVal_int(obj1, &val2);
39848 if (!SWIG_IsOK(ecode2)) {
39849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39850 }
39851 arg2 = static_cast< int >(val2);
39852 {
39853 PyThreadState* __tstate = wxPyBeginAllowThreads();
39854 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 {
39859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39860 }
39861 return resultobj;
39862 fail:
39863 return NULL;
39864 }
39865
39866
39867 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39868 PyObject *resultobj = 0;
39869 wxMenu *arg1 = (wxMenu *) 0 ;
39870 int arg2 ;
39871 bool arg3 ;
39872 void *argp1 = 0 ;
39873 int res1 = 0 ;
39874 int val2 ;
39875 int ecode2 = 0 ;
39876 bool val3 ;
39877 int ecode3 = 0 ;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 PyObject * obj2 = 0 ;
39881 char * kwnames[] = {
39882 (char *) "self",(char *) "id",(char *) "check", NULL
39883 };
39884
39885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39887 if (!SWIG_IsOK(res1)) {
39888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39889 }
39890 arg1 = reinterpret_cast< wxMenu * >(argp1);
39891 ecode2 = SWIG_AsVal_int(obj1, &val2);
39892 if (!SWIG_IsOK(ecode2)) {
39893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39894 }
39895 arg2 = static_cast< int >(val2);
39896 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39897 if (!SWIG_IsOK(ecode3)) {
39898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39899 }
39900 arg3 = static_cast< bool >(val3);
39901 {
39902 PyThreadState* __tstate = wxPyBeginAllowThreads();
39903 (arg1)->Check(arg2,arg3);
39904 wxPyEndAllowThreads(__tstate);
39905 if (PyErr_Occurred()) SWIG_fail;
39906 }
39907 resultobj = SWIG_Py_Void();
39908 return resultobj;
39909 fail:
39910 return NULL;
39911 }
39912
39913
39914 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39915 PyObject *resultobj = 0;
39916 wxMenu *arg1 = (wxMenu *) 0 ;
39917 int arg2 ;
39918 bool result;
39919 void *argp1 = 0 ;
39920 int res1 = 0 ;
39921 int val2 ;
39922 int ecode2 = 0 ;
39923 PyObject * obj0 = 0 ;
39924 PyObject * obj1 = 0 ;
39925 char * kwnames[] = {
39926 (char *) "self",(char *) "id", NULL
39927 };
39928
39929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39931 if (!SWIG_IsOK(res1)) {
39932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39933 }
39934 arg1 = reinterpret_cast< wxMenu * >(argp1);
39935 ecode2 = SWIG_AsVal_int(obj1, &val2);
39936 if (!SWIG_IsOK(ecode2)) {
39937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39938 }
39939 arg2 = static_cast< int >(val2);
39940 {
39941 PyThreadState* __tstate = wxPyBeginAllowThreads();
39942 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39943 wxPyEndAllowThreads(__tstate);
39944 if (PyErr_Occurred()) SWIG_fail;
39945 }
39946 {
39947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39948 }
39949 return resultobj;
39950 fail:
39951 return NULL;
39952 }
39953
39954
39955 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39956 PyObject *resultobj = 0;
39957 wxMenu *arg1 = (wxMenu *) 0 ;
39958 int arg2 ;
39959 wxString *arg3 = 0 ;
39960 void *argp1 = 0 ;
39961 int res1 = 0 ;
39962 int val2 ;
39963 int ecode2 = 0 ;
39964 bool temp3 = false ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 PyObject * obj2 = 0 ;
39968 char * kwnames[] = {
39969 (char *) "self",(char *) "id",(char *) "label", NULL
39970 };
39971
39972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39974 if (!SWIG_IsOK(res1)) {
39975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39976 }
39977 arg1 = reinterpret_cast< wxMenu * >(argp1);
39978 ecode2 = SWIG_AsVal_int(obj1, &val2);
39979 if (!SWIG_IsOK(ecode2)) {
39980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39981 }
39982 arg2 = static_cast< int >(val2);
39983 {
39984 arg3 = wxString_in_helper(obj2);
39985 if (arg3 == NULL) SWIG_fail;
39986 temp3 = true;
39987 }
39988 {
39989 PyThreadState* __tstate = wxPyBeginAllowThreads();
39990 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39991 wxPyEndAllowThreads(__tstate);
39992 if (PyErr_Occurred()) SWIG_fail;
39993 }
39994 resultobj = SWIG_Py_Void();
39995 {
39996 if (temp3)
39997 delete arg3;
39998 }
39999 return resultobj;
40000 fail:
40001 {
40002 if (temp3)
40003 delete arg3;
40004 }
40005 return NULL;
40006 }
40007
40008
40009 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40010 PyObject *resultobj = 0;
40011 wxMenu *arg1 = (wxMenu *) 0 ;
40012 int arg2 ;
40013 wxString result;
40014 void *argp1 = 0 ;
40015 int res1 = 0 ;
40016 int val2 ;
40017 int ecode2 = 0 ;
40018 PyObject * obj0 = 0 ;
40019 PyObject * obj1 = 0 ;
40020 char * kwnames[] = {
40021 (char *) "self",(char *) "id", NULL
40022 };
40023
40024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40026 if (!SWIG_IsOK(res1)) {
40027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40028 }
40029 arg1 = reinterpret_cast< wxMenu * >(argp1);
40030 ecode2 = SWIG_AsVal_int(obj1, &val2);
40031 if (!SWIG_IsOK(ecode2)) {
40032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40033 }
40034 arg2 = static_cast< int >(val2);
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40038 wxPyEndAllowThreads(__tstate);
40039 if (PyErr_Occurred()) SWIG_fail;
40040 }
40041 {
40042 #if wxUSE_UNICODE
40043 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40044 #else
40045 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40046 #endif
40047 }
40048 return resultobj;
40049 fail:
40050 return NULL;
40051 }
40052
40053
40054 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40055 PyObject *resultobj = 0;
40056 wxMenu *arg1 = (wxMenu *) 0 ;
40057 int arg2 ;
40058 wxString *arg3 = 0 ;
40059 void *argp1 = 0 ;
40060 int res1 = 0 ;
40061 int val2 ;
40062 int ecode2 = 0 ;
40063 bool temp3 = false ;
40064 PyObject * obj0 = 0 ;
40065 PyObject * obj1 = 0 ;
40066 PyObject * obj2 = 0 ;
40067 char * kwnames[] = {
40068 (char *) "self",(char *) "id",(char *) "helpString", NULL
40069 };
40070
40071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40073 if (!SWIG_IsOK(res1)) {
40074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40075 }
40076 arg1 = reinterpret_cast< wxMenu * >(argp1);
40077 ecode2 = SWIG_AsVal_int(obj1, &val2);
40078 if (!SWIG_IsOK(ecode2)) {
40079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40080 }
40081 arg2 = static_cast< int >(val2);
40082 {
40083 arg3 = wxString_in_helper(obj2);
40084 if (arg3 == NULL) SWIG_fail;
40085 temp3 = true;
40086 }
40087 {
40088 PyThreadState* __tstate = wxPyBeginAllowThreads();
40089 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40090 wxPyEndAllowThreads(__tstate);
40091 if (PyErr_Occurred()) SWIG_fail;
40092 }
40093 resultobj = SWIG_Py_Void();
40094 {
40095 if (temp3)
40096 delete arg3;
40097 }
40098 return resultobj;
40099 fail:
40100 {
40101 if (temp3)
40102 delete arg3;
40103 }
40104 return NULL;
40105 }
40106
40107
40108 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40109 PyObject *resultobj = 0;
40110 wxMenu *arg1 = (wxMenu *) 0 ;
40111 int arg2 ;
40112 wxString result;
40113 void *argp1 = 0 ;
40114 int res1 = 0 ;
40115 int val2 ;
40116 int ecode2 = 0 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 char * kwnames[] = {
40120 (char *) "self",(char *) "id", NULL
40121 };
40122
40123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40125 if (!SWIG_IsOK(res1)) {
40126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40127 }
40128 arg1 = reinterpret_cast< wxMenu * >(argp1);
40129 ecode2 = SWIG_AsVal_int(obj1, &val2);
40130 if (!SWIG_IsOK(ecode2)) {
40131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40132 }
40133 arg2 = static_cast< int >(val2);
40134 {
40135 PyThreadState* __tstate = wxPyBeginAllowThreads();
40136 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 {
40141 #if wxUSE_UNICODE
40142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40143 #else
40144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40145 #endif
40146 }
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40154 PyObject *resultobj = 0;
40155 wxMenu *arg1 = (wxMenu *) 0 ;
40156 wxString *arg2 = 0 ;
40157 void *argp1 = 0 ;
40158 int res1 = 0 ;
40159 bool temp2 = false ;
40160 PyObject * obj0 = 0 ;
40161 PyObject * obj1 = 0 ;
40162 char * kwnames[] = {
40163 (char *) "self",(char *) "title", NULL
40164 };
40165
40166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40168 if (!SWIG_IsOK(res1)) {
40169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40170 }
40171 arg1 = reinterpret_cast< wxMenu * >(argp1);
40172 {
40173 arg2 = wxString_in_helper(obj1);
40174 if (arg2 == NULL) SWIG_fail;
40175 temp2 = true;
40176 }
40177 {
40178 PyThreadState* __tstate = wxPyBeginAllowThreads();
40179 (arg1)->SetTitle((wxString const &)*arg2);
40180 wxPyEndAllowThreads(__tstate);
40181 if (PyErr_Occurred()) SWIG_fail;
40182 }
40183 resultobj = SWIG_Py_Void();
40184 {
40185 if (temp2)
40186 delete arg2;
40187 }
40188 return resultobj;
40189 fail:
40190 {
40191 if (temp2)
40192 delete arg2;
40193 }
40194 return NULL;
40195 }
40196
40197
40198 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40199 PyObject *resultobj = 0;
40200 wxMenu *arg1 = (wxMenu *) 0 ;
40201 wxString result;
40202 void *argp1 = 0 ;
40203 int res1 = 0 ;
40204 PyObject *swig_obj[1] ;
40205
40206 if (!args) SWIG_fail;
40207 swig_obj[0] = args;
40208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40209 if (!SWIG_IsOK(res1)) {
40210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40211 }
40212 arg1 = reinterpret_cast< wxMenu * >(argp1);
40213 {
40214 PyThreadState* __tstate = wxPyBeginAllowThreads();
40215 result = ((wxMenu const *)arg1)->GetTitle();
40216 wxPyEndAllowThreads(__tstate);
40217 if (PyErr_Occurred()) SWIG_fail;
40218 }
40219 {
40220 #if wxUSE_UNICODE
40221 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40222 #else
40223 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40224 #endif
40225 }
40226 return resultobj;
40227 fail:
40228 return NULL;
40229 }
40230
40231
40232 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40233 PyObject *resultobj = 0;
40234 wxMenu *arg1 = (wxMenu *) 0 ;
40235 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40236 void *argp1 = 0 ;
40237 int res1 = 0 ;
40238 void *argp2 = 0 ;
40239 int res2 = 0 ;
40240 PyObject * obj0 = 0 ;
40241 PyObject * obj1 = 0 ;
40242 char * kwnames[] = {
40243 (char *) "self",(char *) "handler", NULL
40244 };
40245
40246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40248 if (!SWIG_IsOK(res1)) {
40249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40250 }
40251 arg1 = reinterpret_cast< wxMenu * >(argp1);
40252 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40253 if (!SWIG_IsOK(res2)) {
40254 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40255 }
40256 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40257 {
40258 PyThreadState* __tstate = wxPyBeginAllowThreads();
40259 (arg1)->SetEventHandler(arg2);
40260 wxPyEndAllowThreads(__tstate);
40261 if (PyErr_Occurred()) SWIG_fail;
40262 }
40263 resultobj = SWIG_Py_Void();
40264 return resultobj;
40265 fail:
40266 return NULL;
40267 }
40268
40269
40270 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40271 PyObject *resultobj = 0;
40272 wxMenu *arg1 = (wxMenu *) 0 ;
40273 wxEvtHandler *result = 0 ;
40274 void *argp1 = 0 ;
40275 int res1 = 0 ;
40276 PyObject *swig_obj[1] ;
40277
40278 if (!args) SWIG_fail;
40279 swig_obj[0] = args;
40280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40281 if (!SWIG_IsOK(res1)) {
40282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40283 }
40284 arg1 = reinterpret_cast< wxMenu * >(argp1);
40285 {
40286 PyThreadState* __tstate = wxPyBeginAllowThreads();
40287 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40288 wxPyEndAllowThreads(__tstate);
40289 if (PyErr_Occurred()) SWIG_fail;
40290 }
40291 {
40292 resultobj = wxPyMake_wxObject(result, 0);
40293 }
40294 return resultobj;
40295 fail:
40296 return NULL;
40297 }
40298
40299
40300 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40301 PyObject *resultobj = 0;
40302 wxMenu *arg1 = (wxMenu *) 0 ;
40303 wxWindow *arg2 = (wxWindow *) 0 ;
40304 void *argp1 = 0 ;
40305 int res1 = 0 ;
40306 void *argp2 = 0 ;
40307 int res2 = 0 ;
40308 PyObject * obj0 = 0 ;
40309 PyObject * obj1 = 0 ;
40310 char * kwnames[] = {
40311 (char *) "self",(char *) "win", NULL
40312 };
40313
40314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40316 if (!SWIG_IsOK(res1)) {
40317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40318 }
40319 arg1 = reinterpret_cast< wxMenu * >(argp1);
40320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40321 if (!SWIG_IsOK(res2)) {
40322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40323 }
40324 arg2 = reinterpret_cast< wxWindow * >(argp2);
40325 {
40326 PyThreadState* __tstate = wxPyBeginAllowThreads();
40327 (arg1)->SetInvokingWindow(arg2);
40328 wxPyEndAllowThreads(__tstate);
40329 if (PyErr_Occurred()) SWIG_fail;
40330 }
40331 resultobj = SWIG_Py_Void();
40332 return resultobj;
40333 fail:
40334 return NULL;
40335 }
40336
40337
40338 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40339 PyObject *resultobj = 0;
40340 wxMenu *arg1 = (wxMenu *) 0 ;
40341 wxWindow *result = 0 ;
40342 void *argp1 = 0 ;
40343 int res1 = 0 ;
40344 PyObject *swig_obj[1] ;
40345
40346 if (!args) SWIG_fail;
40347 swig_obj[0] = args;
40348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40349 if (!SWIG_IsOK(res1)) {
40350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40351 }
40352 arg1 = reinterpret_cast< wxMenu * >(argp1);
40353 {
40354 PyThreadState* __tstate = wxPyBeginAllowThreads();
40355 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40356 wxPyEndAllowThreads(__tstate);
40357 if (PyErr_Occurred()) SWIG_fail;
40358 }
40359 {
40360 resultobj = wxPyMake_wxObject(result, 0);
40361 }
40362 return resultobj;
40363 fail:
40364 return NULL;
40365 }
40366
40367
40368 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40369 PyObject *resultobj = 0;
40370 wxMenu *arg1 = (wxMenu *) 0 ;
40371 long result;
40372 void *argp1 = 0 ;
40373 int res1 = 0 ;
40374 PyObject *swig_obj[1] ;
40375
40376 if (!args) SWIG_fail;
40377 swig_obj[0] = args;
40378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40379 if (!SWIG_IsOK(res1)) {
40380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40381 }
40382 arg1 = reinterpret_cast< wxMenu * >(argp1);
40383 {
40384 PyThreadState* __tstate = wxPyBeginAllowThreads();
40385 result = (long)((wxMenu const *)arg1)->GetStyle();
40386 wxPyEndAllowThreads(__tstate);
40387 if (PyErr_Occurred()) SWIG_fail;
40388 }
40389 resultobj = SWIG_From_long(static_cast< long >(result));
40390 return resultobj;
40391 fail:
40392 return NULL;
40393 }
40394
40395
40396 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40397 PyObject *resultobj = 0;
40398 wxMenu *arg1 = (wxMenu *) 0 ;
40399 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40400 void *argp1 = 0 ;
40401 int res1 = 0 ;
40402 void *argp2 = 0 ;
40403 int res2 = 0 ;
40404 PyObject * obj0 = 0 ;
40405 PyObject * obj1 = 0 ;
40406 char * kwnames[] = {
40407 (char *) "self",(char *) "source", NULL
40408 };
40409
40410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40412 if (!SWIG_IsOK(res1)) {
40413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40414 }
40415 arg1 = reinterpret_cast< wxMenu * >(argp1);
40416 if (obj1) {
40417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40418 if (!SWIG_IsOK(res2)) {
40419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40420 }
40421 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40422 }
40423 {
40424 PyThreadState* __tstate = wxPyBeginAllowThreads();
40425 (arg1)->UpdateUI(arg2);
40426 wxPyEndAllowThreads(__tstate);
40427 if (PyErr_Occurred()) SWIG_fail;
40428 }
40429 resultobj = SWIG_Py_Void();
40430 return resultobj;
40431 fail:
40432 return NULL;
40433 }
40434
40435
40436 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40437 PyObject *resultobj = 0;
40438 wxMenu *arg1 = (wxMenu *) 0 ;
40439 wxMenuBar *result = 0 ;
40440 void *argp1 = 0 ;
40441 int res1 = 0 ;
40442 PyObject *swig_obj[1] ;
40443
40444 if (!args) SWIG_fail;
40445 swig_obj[0] = args;
40446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40447 if (!SWIG_IsOK(res1)) {
40448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40449 }
40450 arg1 = reinterpret_cast< wxMenu * >(argp1);
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40454 wxPyEndAllowThreads(__tstate);
40455 if (PyErr_Occurred()) SWIG_fail;
40456 }
40457 {
40458 resultobj = wxPyMake_wxObject(result, (bool)0);
40459 }
40460 return resultobj;
40461 fail:
40462 return NULL;
40463 }
40464
40465
40466 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40467 PyObject *resultobj = 0;
40468 wxMenu *arg1 = (wxMenu *) 0 ;
40469 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40470 void *argp1 = 0 ;
40471 int res1 = 0 ;
40472 void *argp2 = 0 ;
40473 int res2 = 0 ;
40474 PyObject * obj0 = 0 ;
40475 PyObject * obj1 = 0 ;
40476 char * kwnames[] = {
40477 (char *) "self",(char *) "menubar", NULL
40478 };
40479
40480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40482 if (!SWIG_IsOK(res1)) {
40483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40484 }
40485 arg1 = reinterpret_cast< wxMenu * >(argp1);
40486 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40487 if (!SWIG_IsOK(res2)) {
40488 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40489 }
40490 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40491 {
40492 PyThreadState* __tstate = wxPyBeginAllowThreads();
40493 (arg1)->Attach(arg2);
40494 wxPyEndAllowThreads(__tstate);
40495 if (PyErr_Occurred()) SWIG_fail;
40496 }
40497 resultobj = SWIG_Py_Void();
40498 return resultobj;
40499 fail:
40500 return NULL;
40501 }
40502
40503
40504 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40505 PyObject *resultobj = 0;
40506 wxMenu *arg1 = (wxMenu *) 0 ;
40507 void *argp1 = 0 ;
40508 int res1 = 0 ;
40509 PyObject *swig_obj[1] ;
40510
40511 if (!args) SWIG_fail;
40512 swig_obj[0] = args;
40513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40514 if (!SWIG_IsOK(res1)) {
40515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40516 }
40517 arg1 = reinterpret_cast< wxMenu * >(argp1);
40518 {
40519 PyThreadState* __tstate = wxPyBeginAllowThreads();
40520 (arg1)->Detach();
40521 wxPyEndAllowThreads(__tstate);
40522 if (PyErr_Occurred()) SWIG_fail;
40523 }
40524 resultobj = SWIG_Py_Void();
40525 return resultobj;
40526 fail:
40527 return NULL;
40528 }
40529
40530
40531 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40532 PyObject *resultobj = 0;
40533 wxMenu *arg1 = (wxMenu *) 0 ;
40534 bool result;
40535 void *argp1 = 0 ;
40536 int res1 = 0 ;
40537 PyObject *swig_obj[1] ;
40538
40539 if (!args) SWIG_fail;
40540 swig_obj[0] = args;
40541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40542 if (!SWIG_IsOK(res1)) {
40543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40544 }
40545 arg1 = reinterpret_cast< wxMenu * >(argp1);
40546 {
40547 PyThreadState* __tstate = wxPyBeginAllowThreads();
40548 result = (bool)((wxMenu const *)arg1)->IsAttached();
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 {
40553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40554 }
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40562 PyObject *resultobj = 0;
40563 wxMenu *arg1 = (wxMenu *) 0 ;
40564 wxMenu *arg2 = (wxMenu *) 0 ;
40565 void *argp1 = 0 ;
40566 int res1 = 0 ;
40567 void *argp2 = 0 ;
40568 int res2 = 0 ;
40569 PyObject * obj0 = 0 ;
40570 PyObject * obj1 = 0 ;
40571 char * kwnames[] = {
40572 (char *) "self",(char *) "parent", NULL
40573 };
40574
40575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40577 if (!SWIG_IsOK(res1)) {
40578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40579 }
40580 arg1 = reinterpret_cast< wxMenu * >(argp1);
40581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40582 if (!SWIG_IsOK(res2)) {
40583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40584 }
40585 arg2 = reinterpret_cast< wxMenu * >(argp2);
40586 {
40587 PyThreadState* __tstate = wxPyBeginAllowThreads();
40588 (arg1)->SetParent(arg2);
40589 wxPyEndAllowThreads(__tstate);
40590 if (PyErr_Occurred()) SWIG_fail;
40591 }
40592 resultobj = SWIG_Py_Void();
40593 return resultobj;
40594 fail:
40595 return NULL;
40596 }
40597
40598
40599 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40600 PyObject *resultobj = 0;
40601 wxMenu *arg1 = (wxMenu *) 0 ;
40602 wxMenu *result = 0 ;
40603 void *argp1 = 0 ;
40604 int res1 = 0 ;
40605 PyObject *swig_obj[1] ;
40606
40607 if (!args) SWIG_fail;
40608 swig_obj[0] = args;
40609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40610 if (!SWIG_IsOK(res1)) {
40611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40612 }
40613 arg1 = reinterpret_cast< wxMenu * >(argp1);
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40617 wxPyEndAllowThreads(__tstate);
40618 if (PyErr_Occurred()) SWIG_fail;
40619 }
40620 {
40621 resultobj = wxPyMake_wxObject(result, 0);
40622 }
40623 return resultobj;
40624 fail:
40625 return NULL;
40626 }
40627
40628
40629 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40630 PyObject *obj;
40631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40632 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40633 return SWIG_Py_Void();
40634 }
40635
40636 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40637 return SWIG_Python_InitShadowInstance(args);
40638 }
40639
40640 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40641 PyObject *resultobj = 0;
40642 long arg1 = (long) 0 ;
40643 wxMenuBar *result = 0 ;
40644 long val1 ;
40645 int ecode1 = 0 ;
40646 PyObject * obj0 = 0 ;
40647 char * kwnames[] = {
40648 (char *) "style", NULL
40649 };
40650
40651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40652 if (obj0) {
40653 ecode1 = SWIG_AsVal_long(obj0, &val1);
40654 if (!SWIG_IsOK(ecode1)) {
40655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40656 }
40657 arg1 = static_cast< long >(val1);
40658 }
40659 {
40660 if (!wxPyCheckForApp()) SWIG_fail;
40661 PyThreadState* __tstate = wxPyBeginAllowThreads();
40662 result = (wxMenuBar *)new wxMenuBar(arg1);
40663 wxPyEndAllowThreads(__tstate);
40664 if (PyErr_Occurred()) SWIG_fail;
40665 }
40666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40667 return resultobj;
40668 fail:
40669 return NULL;
40670 }
40671
40672
40673 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40674 PyObject *resultobj = 0;
40675 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40676 wxMenu *arg2 = (wxMenu *) 0 ;
40677 wxString *arg3 = 0 ;
40678 bool result;
40679 void *argp1 = 0 ;
40680 int res1 = 0 ;
40681 void *argp2 = 0 ;
40682 int res2 = 0 ;
40683 bool temp3 = false ;
40684 PyObject * obj0 = 0 ;
40685 PyObject * obj1 = 0 ;
40686 PyObject * obj2 = 0 ;
40687 char * kwnames[] = {
40688 (char *) "self",(char *) "menu",(char *) "title", NULL
40689 };
40690
40691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40693 if (!SWIG_IsOK(res1)) {
40694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40695 }
40696 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40697 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40698 if (!SWIG_IsOK(res2)) {
40699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40700 }
40701 arg2 = reinterpret_cast< wxMenu * >(argp2);
40702 {
40703 arg3 = wxString_in_helper(obj2);
40704 if (arg3 == NULL) SWIG_fail;
40705 temp3 = true;
40706 }
40707 {
40708 PyThreadState* __tstate = wxPyBeginAllowThreads();
40709 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40710 wxPyEndAllowThreads(__tstate);
40711 if (PyErr_Occurred()) SWIG_fail;
40712 }
40713 {
40714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40715 }
40716 {
40717 if (temp3)
40718 delete arg3;
40719 }
40720 return resultobj;
40721 fail:
40722 {
40723 if (temp3)
40724 delete arg3;
40725 }
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40731 PyObject *resultobj = 0;
40732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40733 size_t arg2 ;
40734 wxMenu *arg3 = (wxMenu *) 0 ;
40735 wxString *arg4 = 0 ;
40736 bool result;
40737 void *argp1 = 0 ;
40738 int res1 = 0 ;
40739 size_t val2 ;
40740 int ecode2 = 0 ;
40741 void *argp3 = 0 ;
40742 int res3 = 0 ;
40743 bool temp4 = false ;
40744 PyObject * obj0 = 0 ;
40745 PyObject * obj1 = 0 ;
40746 PyObject * obj2 = 0 ;
40747 PyObject * obj3 = 0 ;
40748 char * kwnames[] = {
40749 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40750 };
40751
40752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40754 if (!SWIG_IsOK(res1)) {
40755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40756 }
40757 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40758 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40759 if (!SWIG_IsOK(ecode2)) {
40760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40761 }
40762 arg2 = static_cast< size_t >(val2);
40763 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40764 if (!SWIG_IsOK(res3)) {
40765 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40766 }
40767 arg3 = reinterpret_cast< wxMenu * >(argp3);
40768 {
40769 arg4 = wxString_in_helper(obj3);
40770 if (arg4 == NULL) SWIG_fail;
40771 temp4 = true;
40772 }
40773 {
40774 PyThreadState* __tstate = wxPyBeginAllowThreads();
40775 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40776 wxPyEndAllowThreads(__tstate);
40777 if (PyErr_Occurred()) SWIG_fail;
40778 }
40779 {
40780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40781 }
40782 {
40783 if (temp4)
40784 delete arg4;
40785 }
40786 return resultobj;
40787 fail:
40788 {
40789 if (temp4)
40790 delete arg4;
40791 }
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40797 PyObject *resultobj = 0;
40798 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40799 size_t result;
40800 void *argp1 = 0 ;
40801 int res1 = 0 ;
40802 PyObject *swig_obj[1] ;
40803
40804 if (!args) SWIG_fail;
40805 swig_obj[0] = args;
40806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40807 if (!SWIG_IsOK(res1)) {
40808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40809 }
40810 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40811 {
40812 PyThreadState* __tstate = wxPyBeginAllowThreads();
40813 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40814 wxPyEndAllowThreads(__tstate);
40815 if (PyErr_Occurred()) SWIG_fail;
40816 }
40817 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40818 return resultobj;
40819 fail:
40820 return NULL;
40821 }
40822
40823
40824 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40825 PyObject *resultobj = 0;
40826 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40827 size_t arg2 ;
40828 wxMenu *result = 0 ;
40829 void *argp1 = 0 ;
40830 int res1 = 0 ;
40831 size_t val2 ;
40832 int ecode2 = 0 ;
40833 PyObject * obj0 = 0 ;
40834 PyObject * obj1 = 0 ;
40835 char * kwnames[] = {
40836 (char *) "self",(char *) "pos", NULL
40837 };
40838
40839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40841 if (!SWIG_IsOK(res1)) {
40842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40843 }
40844 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40845 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40846 if (!SWIG_IsOK(ecode2)) {
40847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40848 }
40849 arg2 = static_cast< size_t >(val2);
40850 {
40851 PyThreadState* __tstate = wxPyBeginAllowThreads();
40852 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 {
40857 resultobj = wxPyMake_wxObject(result, 0);
40858 }
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj = 0;
40867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40868 size_t arg2 ;
40869 wxMenu *arg3 = (wxMenu *) 0 ;
40870 wxString *arg4 = 0 ;
40871 wxMenu *result = 0 ;
40872 void *argp1 = 0 ;
40873 int res1 = 0 ;
40874 size_t val2 ;
40875 int ecode2 = 0 ;
40876 void *argp3 = 0 ;
40877 int res3 = 0 ;
40878 bool temp4 = false ;
40879 PyObject * obj0 = 0 ;
40880 PyObject * obj1 = 0 ;
40881 PyObject * obj2 = 0 ;
40882 PyObject * obj3 = 0 ;
40883 char * kwnames[] = {
40884 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40885 };
40886
40887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40889 if (!SWIG_IsOK(res1)) {
40890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40891 }
40892 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40893 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40894 if (!SWIG_IsOK(ecode2)) {
40895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40896 }
40897 arg2 = static_cast< size_t >(val2);
40898 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40899 if (!SWIG_IsOK(res3)) {
40900 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40901 }
40902 arg3 = reinterpret_cast< wxMenu * >(argp3);
40903 {
40904 arg4 = wxString_in_helper(obj3);
40905 if (arg4 == NULL) SWIG_fail;
40906 temp4 = true;
40907 }
40908 {
40909 PyThreadState* __tstate = wxPyBeginAllowThreads();
40910 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40911 wxPyEndAllowThreads(__tstate);
40912 if (PyErr_Occurred()) SWIG_fail;
40913 }
40914 {
40915 resultobj = wxPyMake_wxObject(result, 0);
40916 }
40917 {
40918 if (temp4)
40919 delete arg4;
40920 }
40921 return resultobj;
40922 fail:
40923 {
40924 if (temp4)
40925 delete arg4;
40926 }
40927 return NULL;
40928 }
40929
40930
40931 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40932 PyObject *resultobj = 0;
40933 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40934 size_t arg2 ;
40935 wxMenu *result = 0 ;
40936 void *argp1 = 0 ;
40937 int res1 = 0 ;
40938 size_t val2 ;
40939 int ecode2 = 0 ;
40940 PyObject * obj0 = 0 ;
40941 PyObject * obj1 = 0 ;
40942 char * kwnames[] = {
40943 (char *) "self",(char *) "pos", NULL
40944 };
40945
40946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40948 if (!SWIG_IsOK(res1)) {
40949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40950 }
40951 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40952 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40953 if (!SWIG_IsOK(ecode2)) {
40954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40955 }
40956 arg2 = static_cast< size_t >(val2);
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 result = (wxMenu *)(arg1)->Remove(arg2);
40960 wxPyEndAllowThreads(__tstate);
40961 if (PyErr_Occurred()) SWIG_fail;
40962 }
40963 {
40964 resultobj = wxPyMake_wxObject(result, 0);
40965 }
40966 return resultobj;
40967 fail:
40968 return NULL;
40969 }
40970
40971
40972 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40973 PyObject *resultobj = 0;
40974 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40975 size_t arg2 ;
40976 bool arg3 ;
40977 void *argp1 = 0 ;
40978 int res1 = 0 ;
40979 size_t val2 ;
40980 int ecode2 = 0 ;
40981 bool val3 ;
40982 int ecode3 = 0 ;
40983 PyObject * obj0 = 0 ;
40984 PyObject * obj1 = 0 ;
40985 PyObject * obj2 = 0 ;
40986 char * kwnames[] = {
40987 (char *) "self",(char *) "pos",(char *) "enable", NULL
40988 };
40989
40990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40992 if (!SWIG_IsOK(res1)) {
40993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40994 }
40995 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40996 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40997 if (!SWIG_IsOK(ecode2)) {
40998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40999 }
41000 arg2 = static_cast< size_t >(val2);
41001 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41002 if (!SWIG_IsOK(ecode3)) {
41003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41004 }
41005 arg3 = static_cast< bool >(val3);
41006 {
41007 PyThreadState* __tstate = wxPyBeginAllowThreads();
41008 (arg1)->EnableTop(arg2,arg3);
41009 wxPyEndAllowThreads(__tstate);
41010 if (PyErr_Occurred()) SWIG_fail;
41011 }
41012 resultobj = SWIG_Py_Void();
41013 return resultobj;
41014 fail:
41015 return NULL;
41016 }
41017
41018
41019 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41020 PyObject *resultobj = 0;
41021 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41022 size_t arg2 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 size_t val2 ;
41027 int ecode2 = 0 ;
41028 PyObject * obj0 = 0 ;
41029 PyObject * obj1 = 0 ;
41030 char * kwnames[] = {
41031 (char *) "self",(char *) "pos", NULL
41032 };
41033
41034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41036 if (!SWIG_IsOK(res1)) {
41037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41038 }
41039 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41040 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41041 if (!SWIG_IsOK(ecode2)) {
41042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41043 }
41044 arg2 = static_cast< size_t >(val2);
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41048 wxPyEndAllowThreads(__tstate);
41049 if (PyErr_Occurred()) SWIG_fail;
41050 }
41051 {
41052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41053 }
41054 return resultobj;
41055 fail:
41056 return NULL;
41057 }
41058
41059
41060 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41061 PyObject *resultobj = 0;
41062 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41063 size_t arg2 ;
41064 wxString *arg3 = 0 ;
41065 void *argp1 = 0 ;
41066 int res1 = 0 ;
41067 size_t val2 ;
41068 int ecode2 = 0 ;
41069 bool temp3 = false ;
41070 PyObject * obj0 = 0 ;
41071 PyObject * obj1 = 0 ;
41072 PyObject * obj2 = 0 ;
41073 char * kwnames[] = {
41074 (char *) "self",(char *) "pos",(char *) "label", NULL
41075 };
41076
41077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41079 if (!SWIG_IsOK(res1)) {
41080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41081 }
41082 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41083 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41084 if (!SWIG_IsOK(ecode2)) {
41085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41086 }
41087 arg2 = static_cast< size_t >(val2);
41088 {
41089 arg3 = wxString_in_helper(obj2);
41090 if (arg3 == NULL) SWIG_fail;
41091 temp3 = true;
41092 }
41093 {
41094 PyThreadState* __tstate = wxPyBeginAllowThreads();
41095 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41096 wxPyEndAllowThreads(__tstate);
41097 if (PyErr_Occurred()) SWIG_fail;
41098 }
41099 resultobj = SWIG_Py_Void();
41100 {
41101 if (temp3)
41102 delete arg3;
41103 }
41104 return resultobj;
41105 fail:
41106 {
41107 if (temp3)
41108 delete arg3;
41109 }
41110 return NULL;
41111 }
41112
41113
41114 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41115 PyObject *resultobj = 0;
41116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41117 size_t arg2 ;
41118 wxString result;
41119 void *argp1 = 0 ;
41120 int res1 = 0 ;
41121 size_t val2 ;
41122 int ecode2 = 0 ;
41123 PyObject * obj0 = 0 ;
41124 PyObject * obj1 = 0 ;
41125 char * kwnames[] = {
41126 (char *) "self",(char *) "pos", NULL
41127 };
41128
41129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41131 if (!SWIG_IsOK(res1)) {
41132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41133 }
41134 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41135 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41136 if (!SWIG_IsOK(ecode2)) {
41137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41138 }
41139 arg2 = static_cast< size_t >(val2);
41140 {
41141 PyThreadState* __tstate = wxPyBeginAllowThreads();
41142 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41143 wxPyEndAllowThreads(__tstate);
41144 if (PyErr_Occurred()) SWIG_fail;
41145 }
41146 {
41147 #if wxUSE_UNICODE
41148 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41149 #else
41150 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41151 #endif
41152 }
41153 return resultobj;
41154 fail:
41155 return NULL;
41156 }
41157
41158
41159 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41160 PyObject *resultobj = 0;
41161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41162 wxString *arg2 = 0 ;
41163 wxString *arg3 = 0 ;
41164 int result;
41165 void *argp1 = 0 ;
41166 int res1 = 0 ;
41167 bool temp2 = false ;
41168 bool temp3 = false ;
41169 PyObject * obj0 = 0 ;
41170 PyObject * obj1 = 0 ;
41171 PyObject * obj2 = 0 ;
41172 char * kwnames[] = {
41173 (char *) "self",(char *) "menu",(char *) "item", NULL
41174 };
41175
41176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41178 if (!SWIG_IsOK(res1)) {
41179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41180 }
41181 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41182 {
41183 arg2 = wxString_in_helper(obj1);
41184 if (arg2 == NULL) SWIG_fail;
41185 temp2 = true;
41186 }
41187 {
41188 arg3 = wxString_in_helper(obj2);
41189 if (arg3 == NULL) SWIG_fail;
41190 temp3 = true;
41191 }
41192 {
41193 PyThreadState* __tstate = wxPyBeginAllowThreads();
41194 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41195 wxPyEndAllowThreads(__tstate);
41196 if (PyErr_Occurred()) SWIG_fail;
41197 }
41198 resultobj = SWIG_From_int(static_cast< int >(result));
41199 {
41200 if (temp2)
41201 delete arg2;
41202 }
41203 {
41204 if (temp3)
41205 delete arg3;
41206 }
41207 return resultobj;
41208 fail:
41209 {
41210 if (temp2)
41211 delete arg2;
41212 }
41213 {
41214 if (temp3)
41215 delete arg3;
41216 }
41217 return NULL;
41218 }
41219
41220
41221 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41222 PyObject *resultobj = 0;
41223 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41224 int arg2 ;
41225 wxMenuItem *result = 0 ;
41226 void *argp1 = 0 ;
41227 int res1 = 0 ;
41228 int val2 ;
41229 int ecode2 = 0 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char * kwnames[] = {
41233 (char *) "self",(char *) "id", NULL
41234 };
41235
41236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41238 if (!SWIG_IsOK(res1)) {
41239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41240 }
41241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41242 ecode2 = SWIG_AsVal_int(obj1, &val2);
41243 if (!SWIG_IsOK(ecode2)) {
41244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41245 }
41246 arg2 = static_cast< int >(val2);
41247 {
41248 PyThreadState* __tstate = wxPyBeginAllowThreads();
41249 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41250 wxPyEndAllowThreads(__tstate);
41251 if (PyErr_Occurred()) SWIG_fail;
41252 }
41253 {
41254 resultobj = wxPyMake_wxObject(result, (bool)0);
41255 }
41256 return resultobj;
41257 fail:
41258 return NULL;
41259 }
41260
41261
41262 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41263 PyObject *resultobj = 0;
41264 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41265 wxString *arg2 = 0 ;
41266 int result;
41267 void *argp1 = 0 ;
41268 int res1 = 0 ;
41269 bool temp2 = false ;
41270 PyObject * obj0 = 0 ;
41271 PyObject * obj1 = 0 ;
41272 char * kwnames[] = {
41273 (char *) "self",(char *) "title", NULL
41274 };
41275
41276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41278 if (!SWIG_IsOK(res1)) {
41279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41280 }
41281 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41282 {
41283 arg2 = wxString_in_helper(obj1);
41284 if (arg2 == NULL) SWIG_fail;
41285 temp2 = true;
41286 }
41287 {
41288 PyThreadState* __tstate = wxPyBeginAllowThreads();
41289 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41290 wxPyEndAllowThreads(__tstate);
41291 if (PyErr_Occurred()) SWIG_fail;
41292 }
41293 resultobj = SWIG_From_int(static_cast< int >(result));
41294 {
41295 if (temp2)
41296 delete arg2;
41297 }
41298 return resultobj;
41299 fail:
41300 {
41301 if (temp2)
41302 delete arg2;
41303 }
41304 return NULL;
41305 }
41306
41307
41308 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41309 PyObject *resultobj = 0;
41310 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41311 int arg2 ;
41312 bool arg3 ;
41313 void *argp1 = 0 ;
41314 int res1 = 0 ;
41315 int val2 ;
41316 int ecode2 = 0 ;
41317 bool val3 ;
41318 int ecode3 = 0 ;
41319 PyObject * obj0 = 0 ;
41320 PyObject * obj1 = 0 ;
41321 PyObject * obj2 = 0 ;
41322 char * kwnames[] = {
41323 (char *) "self",(char *) "id",(char *) "enable", NULL
41324 };
41325
41326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41328 if (!SWIG_IsOK(res1)) {
41329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41330 }
41331 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41332 ecode2 = SWIG_AsVal_int(obj1, &val2);
41333 if (!SWIG_IsOK(ecode2)) {
41334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41335 }
41336 arg2 = static_cast< int >(val2);
41337 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41338 if (!SWIG_IsOK(ecode3)) {
41339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41340 }
41341 arg3 = static_cast< bool >(val3);
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 (arg1)->Enable(arg2,arg3);
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 resultobj = SWIG_Py_Void();
41349 return resultobj;
41350 fail:
41351 return NULL;
41352 }
41353
41354
41355 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41356 PyObject *resultobj = 0;
41357 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41358 int arg2 ;
41359 bool arg3 ;
41360 void *argp1 = 0 ;
41361 int res1 = 0 ;
41362 int val2 ;
41363 int ecode2 = 0 ;
41364 bool val3 ;
41365 int ecode3 = 0 ;
41366 PyObject * obj0 = 0 ;
41367 PyObject * obj1 = 0 ;
41368 PyObject * obj2 = 0 ;
41369 char * kwnames[] = {
41370 (char *) "self",(char *) "id",(char *) "check", NULL
41371 };
41372
41373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41375 if (!SWIG_IsOK(res1)) {
41376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41377 }
41378 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41379 ecode2 = SWIG_AsVal_int(obj1, &val2);
41380 if (!SWIG_IsOK(ecode2)) {
41381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41382 }
41383 arg2 = static_cast< int >(val2);
41384 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41385 if (!SWIG_IsOK(ecode3)) {
41386 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41387 }
41388 arg3 = static_cast< bool >(val3);
41389 {
41390 PyThreadState* __tstate = wxPyBeginAllowThreads();
41391 (arg1)->Check(arg2,arg3);
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 resultobj = SWIG_Py_Void();
41396 return resultobj;
41397 fail:
41398 return NULL;
41399 }
41400
41401
41402 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41403 PyObject *resultobj = 0;
41404 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41405 int arg2 ;
41406 bool result;
41407 void *argp1 = 0 ;
41408 int res1 = 0 ;
41409 int val2 ;
41410 int ecode2 = 0 ;
41411 PyObject * obj0 = 0 ;
41412 PyObject * obj1 = 0 ;
41413 char * kwnames[] = {
41414 (char *) "self",(char *) "id", NULL
41415 };
41416
41417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41419 if (!SWIG_IsOK(res1)) {
41420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41421 }
41422 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41423 ecode2 = SWIG_AsVal_int(obj1, &val2);
41424 if (!SWIG_IsOK(ecode2)) {
41425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41426 }
41427 arg2 = static_cast< int >(val2);
41428 {
41429 PyThreadState* __tstate = wxPyBeginAllowThreads();
41430 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41431 wxPyEndAllowThreads(__tstate);
41432 if (PyErr_Occurred()) SWIG_fail;
41433 }
41434 {
41435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41436 }
41437 return resultobj;
41438 fail:
41439 return NULL;
41440 }
41441
41442
41443 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41444 PyObject *resultobj = 0;
41445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41446 int arg2 ;
41447 bool result;
41448 void *argp1 = 0 ;
41449 int res1 = 0 ;
41450 int val2 ;
41451 int ecode2 = 0 ;
41452 PyObject * obj0 = 0 ;
41453 PyObject * obj1 = 0 ;
41454 char * kwnames[] = {
41455 (char *) "self",(char *) "id", NULL
41456 };
41457
41458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41460 if (!SWIG_IsOK(res1)) {
41461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41462 }
41463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41464 ecode2 = SWIG_AsVal_int(obj1, &val2);
41465 if (!SWIG_IsOK(ecode2)) {
41466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41467 }
41468 arg2 = static_cast< int >(val2);
41469 {
41470 PyThreadState* __tstate = wxPyBeginAllowThreads();
41471 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41472 wxPyEndAllowThreads(__tstate);
41473 if (PyErr_Occurred()) SWIG_fail;
41474 }
41475 {
41476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41477 }
41478 return resultobj;
41479 fail:
41480 return NULL;
41481 }
41482
41483
41484 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41485 PyObject *resultobj = 0;
41486 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41487 int arg2 ;
41488 wxString *arg3 = 0 ;
41489 void *argp1 = 0 ;
41490 int res1 = 0 ;
41491 int val2 ;
41492 int ecode2 = 0 ;
41493 bool temp3 = false ;
41494 PyObject * obj0 = 0 ;
41495 PyObject * obj1 = 0 ;
41496 PyObject * obj2 = 0 ;
41497 char * kwnames[] = {
41498 (char *) "self",(char *) "id",(char *) "label", NULL
41499 };
41500
41501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41503 if (!SWIG_IsOK(res1)) {
41504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41505 }
41506 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41507 ecode2 = SWIG_AsVal_int(obj1, &val2);
41508 if (!SWIG_IsOK(ecode2)) {
41509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41510 }
41511 arg2 = static_cast< int >(val2);
41512 {
41513 arg3 = wxString_in_helper(obj2);
41514 if (arg3 == NULL) SWIG_fail;
41515 temp3 = true;
41516 }
41517 {
41518 PyThreadState* __tstate = wxPyBeginAllowThreads();
41519 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41520 wxPyEndAllowThreads(__tstate);
41521 if (PyErr_Occurred()) SWIG_fail;
41522 }
41523 resultobj = SWIG_Py_Void();
41524 {
41525 if (temp3)
41526 delete arg3;
41527 }
41528 return resultobj;
41529 fail:
41530 {
41531 if (temp3)
41532 delete arg3;
41533 }
41534 return NULL;
41535 }
41536
41537
41538 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41539 PyObject *resultobj = 0;
41540 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41541 int arg2 ;
41542 wxString result;
41543 void *argp1 = 0 ;
41544 int res1 = 0 ;
41545 int val2 ;
41546 int ecode2 = 0 ;
41547 PyObject * obj0 = 0 ;
41548 PyObject * obj1 = 0 ;
41549 char * kwnames[] = {
41550 (char *) "self",(char *) "id", NULL
41551 };
41552
41553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41555 if (!SWIG_IsOK(res1)) {
41556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41557 }
41558 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41559 ecode2 = SWIG_AsVal_int(obj1, &val2);
41560 if (!SWIG_IsOK(ecode2)) {
41561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41562 }
41563 arg2 = static_cast< int >(val2);
41564 {
41565 PyThreadState* __tstate = wxPyBeginAllowThreads();
41566 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41567 wxPyEndAllowThreads(__tstate);
41568 if (PyErr_Occurred()) SWIG_fail;
41569 }
41570 {
41571 #if wxUSE_UNICODE
41572 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41573 #else
41574 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41575 #endif
41576 }
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41584 PyObject *resultobj = 0;
41585 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41586 int arg2 ;
41587 wxString *arg3 = 0 ;
41588 void *argp1 = 0 ;
41589 int res1 = 0 ;
41590 int val2 ;
41591 int ecode2 = 0 ;
41592 bool temp3 = false ;
41593 PyObject * obj0 = 0 ;
41594 PyObject * obj1 = 0 ;
41595 PyObject * obj2 = 0 ;
41596 char * kwnames[] = {
41597 (char *) "self",(char *) "id",(char *) "helpString", NULL
41598 };
41599
41600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41602 if (!SWIG_IsOK(res1)) {
41603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41604 }
41605 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41606 ecode2 = SWIG_AsVal_int(obj1, &val2);
41607 if (!SWIG_IsOK(ecode2)) {
41608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41609 }
41610 arg2 = static_cast< int >(val2);
41611 {
41612 arg3 = wxString_in_helper(obj2);
41613 if (arg3 == NULL) SWIG_fail;
41614 temp3 = true;
41615 }
41616 {
41617 PyThreadState* __tstate = wxPyBeginAllowThreads();
41618 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41619 wxPyEndAllowThreads(__tstate);
41620 if (PyErr_Occurred()) SWIG_fail;
41621 }
41622 resultobj = SWIG_Py_Void();
41623 {
41624 if (temp3)
41625 delete arg3;
41626 }
41627 return resultobj;
41628 fail:
41629 {
41630 if (temp3)
41631 delete arg3;
41632 }
41633 return NULL;
41634 }
41635
41636
41637 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41638 PyObject *resultobj = 0;
41639 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41640 int arg2 ;
41641 wxString result;
41642 void *argp1 = 0 ;
41643 int res1 = 0 ;
41644 int val2 ;
41645 int ecode2 = 0 ;
41646 PyObject * obj0 = 0 ;
41647 PyObject * obj1 = 0 ;
41648 char * kwnames[] = {
41649 (char *) "self",(char *) "id", NULL
41650 };
41651
41652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41654 if (!SWIG_IsOK(res1)) {
41655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41656 }
41657 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41658 ecode2 = SWIG_AsVal_int(obj1, &val2);
41659 if (!SWIG_IsOK(ecode2)) {
41660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41661 }
41662 arg2 = static_cast< int >(val2);
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 {
41670 #if wxUSE_UNICODE
41671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41672 #else
41673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41674 #endif
41675 }
41676 return resultobj;
41677 fail:
41678 return NULL;
41679 }
41680
41681
41682 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41683 PyObject *resultobj = 0;
41684 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41685 wxFrame *result = 0 ;
41686 void *argp1 = 0 ;
41687 int res1 = 0 ;
41688 PyObject *swig_obj[1] ;
41689
41690 if (!args) SWIG_fail;
41691 swig_obj[0] = args;
41692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41693 if (!SWIG_IsOK(res1)) {
41694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41695 }
41696 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41700 wxPyEndAllowThreads(__tstate);
41701 if (PyErr_Occurred()) SWIG_fail;
41702 }
41703 {
41704 resultobj = wxPyMake_wxObject(result, (bool)0);
41705 }
41706 return resultobj;
41707 fail:
41708 return NULL;
41709 }
41710
41711
41712 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41713 PyObject *resultobj = 0;
41714 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41715 bool result;
41716 void *argp1 = 0 ;
41717 int res1 = 0 ;
41718 PyObject *swig_obj[1] ;
41719
41720 if (!args) SWIG_fail;
41721 swig_obj[0] = args;
41722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41723 if (!SWIG_IsOK(res1)) {
41724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41725 }
41726 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 {
41734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41735 }
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41743 PyObject *resultobj = 0;
41744 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41745 wxFrame *arg2 = (wxFrame *) 0 ;
41746 void *argp1 = 0 ;
41747 int res1 = 0 ;
41748 void *argp2 = 0 ;
41749 int res2 = 0 ;
41750 PyObject * obj0 = 0 ;
41751 PyObject * obj1 = 0 ;
41752 char * kwnames[] = {
41753 (char *) "self",(char *) "frame", NULL
41754 };
41755
41756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41758 if (!SWIG_IsOK(res1)) {
41759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41760 }
41761 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41763 if (!SWIG_IsOK(res2)) {
41764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41765 }
41766 arg2 = reinterpret_cast< wxFrame * >(argp2);
41767 {
41768 PyThreadState* __tstate = wxPyBeginAllowThreads();
41769 (arg1)->Attach(arg2);
41770 wxPyEndAllowThreads(__tstate);
41771 if (PyErr_Occurred()) SWIG_fail;
41772 }
41773 resultobj = SWIG_Py_Void();
41774 return resultobj;
41775 fail:
41776 return NULL;
41777 }
41778
41779
41780 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41781 PyObject *resultobj = 0;
41782 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41783 void *argp1 = 0 ;
41784 int res1 = 0 ;
41785 PyObject *swig_obj[1] ;
41786
41787 if (!args) SWIG_fail;
41788 swig_obj[0] = args;
41789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41790 if (!SWIG_IsOK(res1)) {
41791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41792 }
41793 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41794 {
41795 PyThreadState* __tstate = wxPyBeginAllowThreads();
41796 (arg1)->Detach();
41797 wxPyEndAllowThreads(__tstate);
41798 if (PyErr_Occurred()) SWIG_fail;
41799 }
41800 resultobj = SWIG_Py_Void();
41801 return resultobj;
41802 fail:
41803 return NULL;
41804 }
41805
41806
41807 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41808 PyObject *resultobj = 0;
41809 bool arg1 ;
41810 bool val1 ;
41811 int ecode1 = 0 ;
41812 PyObject * obj0 = 0 ;
41813 char * kwnames[] = {
41814 (char *) "enable", NULL
41815 };
41816
41817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41818 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41819 if (!SWIG_IsOK(ecode1)) {
41820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41821 }
41822 arg1 = static_cast< bool >(val1);
41823 {
41824 PyThreadState* __tstate = wxPyBeginAllowThreads();
41825 wxMenuBar::SetAutoWindowMenu(arg1);
41826 wxPyEndAllowThreads(__tstate);
41827 if (PyErr_Occurred()) SWIG_fail;
41828 }
41829 resultobj = SWIG_Py_Void();
41830 return resultobj;
41831 fail:
41832 return NULL;
41833 }
41834
41835
41836 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41837 PyObject *resultobj = 0;
41838 bool result;
41839
41840 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 result = (bool)wxMenuBar::GetAutoWindowMenu();
41844 wxPyEndAllowThreads(__tstate);
41845 if (PyErr_Occurred()) SWIG_fail;
41846 }
41847 {
41848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41849 }
41850 return resultobj;
41851 fail:
41852 return NULL;
41853 }
41854
41855
41856 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41857 PyObject *obj;
41858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41859 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41860 return SWIG_Py_Void();
41861 }
41862
41863 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41864 return SWIG_Python_InitShadowInstance(args);
41865 }
41866
41867 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41868 PyObject *resultobj = 0;
41869 wxMenu *arg1 = (wxMenu *) NULL ;
41870 int arg2 = (int) wxID_ANY ;
41871 wxString const &arg3_defvalue = wxPyEmptyString ;
41872 wxString *arg3 = (wxString *) &arg3_defvalue ;
41873 wxString const &arg4_defvalue = wxPyEmptyString ;
41874 wxString *arg4 = (wxString *) &arg4_defvalue ;
41875 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41876 wxMenu *arg6 = (wxMenu *) NULL ;
41877 wxMenuItem *result = 0 ;
41878 void *argp1 = 0 ;
41879 int res1 = 0 ;
41880 int val2 ;
41881 int ecode2 = 0 ;
41882 bool temp3 = false ;
41883 bool temp4 = false ;
41884 int val5 ;
41885 int ecode5 = 0 ;
41886 void *argp6 = 0 ;
41887 int res6 = 0 ;
41888 PyObject * obj0 = 0 ;
41889 PyObject * obj1 = 0 ;
41890 PyObject * obj2 = 0 ;
41891 PyObject * obj3 = 0 ;
41892 PyObject * obj4 = 0 ;
41893 PyObject * obj5 = 0 ;
41894 char * kwnames[] = {
41895 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41896 };
41897
41898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41899 if (obj0) {
41900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41901 if (!SWIG_IsOK(res1)) {
41902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41903 }
41904 arg1 = reinterpret_cast< wxMenu * >(argp1);
41905 }
41906 if (obj1) {
41907 ecode2 = SWIG_AsVal_int(obj1, &val2);
41908 if (!SWIG_IsOK(ecode2)) {
41909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41910 }
41911 arg2 = static_cast< int >(val2);
41912 }
41913 if (obj2) {
41914 {
41915 arg3 = wxString_in_helper(obj2);
41916 if (arg3 == NULL) SWIG_fail;
41917 temp3 = true;
41918 }
41919 }
41920 if (obj3) {
41921 {
41922 arg4 = wxString_in_helper(obj3);
41923 if (arg4 == NULL) SWIG_fail;
41924 temp4 = true;
41925 }
41926 }
41927 if (obj4) {
41928 ecode5 = SWIG_AsVal_int(obj4, &val5);
41929 if (!SWIG_IsOK(ecode5)) {
41930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41931 }
41932 arg5 = static_cast< wxItemKind >(val5);
41933 }
41934 if (obj5) {
41935 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41936 if (!SWIG_IsOK(res6)) {
41937 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41938 }
41939 arg6 = reinterpret_cast< wxMenu * >(argp6);
41940 }
41941 {
41942 PyThreadState* __tstate = wxPyBeginAllowThreads();
41943 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41944 wxPyEndAllowThreads(__tstate);
41945 if (PyErr_Occurred()) SWIG_fail;
41946 }
41947 {
41948 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41949 }
41950 {
41951 if (temp3)
41952 delete arg3;
41953 }
41954 {
41955 if (temp4)
41956 delete arg4;
41957 }
41958 return resultobj;
41959 fail:
41960 {
41961 if (temp3)
41962 delete arg3;
41963 }
41964 {
41965 if (temp4)
41966 delete arg4;
41967 }
41968 return NULL;
41969 }
41970
41971
41972 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41973 PyObject *resultobj = 0;
41974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41975 void *argp1 = 0 ;
41976 int res1 = 0 ;
41977 PyObject *swig_obj[1] ;
41978
41979 if (!args) SWIG_fail;
41980 swig_obj[0] = args;
41981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41982 if (!SWIG_IsOK(res1)) {
41983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41984 }
41985 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41986 {
41987 PyThreadState* __tstate = wxPyBeginAllowThreads();
41988 delete arg1;
41989
41990 wxPyEndAllowThreads(__tstate);
41991 if (PyErr_Occurred()) SWIG_fail;
41992 }
41993 resultobj = SWIG_Py_Void();
41994 return resultobj;
41995 fail:
41996 return NULL;
41997 }
41998
41999
42000 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42001 PyObject *resultobj = 0;
42002 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42003 wxMenu *result = 0 ;
42004 void *argp1 = 0 ;
42005 int res1 = 0 ;
42006 PyObject *swig_obj[1] ;
42007
42008 if (!args) SWIG_fail;
42009 swig_obj[0] = args;
42010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42011 if (!SWIG_IsOK(res1)) {
42012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42013 }
42014 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42015 {
42016 PyThreadState* __tstate = wxPyBeginAllowThreads();
42017 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42018 wxPyEndAllowThreads(__tstate);
42019 if (PyErr_Occurred()) SWIG_fail;
42020 }
42021 {
42022 resultobj = wxPyMake_wxObject(result, 0);
42023 }
42024 return resultobj;
42025 fail:
42026 return NULL;
42027 }
42028
42029
42030 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42031 PyObject *resultobj = 0;
42032 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42033 wxMenu *arg2 = (wxMenu *) 0 ;
42034 void *argp1 = 0 ;
42035 int res1 = 0 ;
42036 void *argp2 = 0 ;
42037 int res2 = 0 ;
42038 PyObject * obj0 = 0 ;
42039 PyObject * obj1 = 0 ;
42040 char * kwnames[] = {
42041 (char *) "self",(char *) "menu", NULL
42042 };
42043
42044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42046 if (!SWIG_IsOK(res1)) {
42047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42048 }
42049 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42051 if (!SWIG_IsOK(res2)) {
42052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42053 }
42054 arg2 = reinterpret_cast< wxMenu * >(argp2);
42055 {
42056 PyThreadState* __tstate = wxPyBeginAllowThreads();
42057 (arg1)->SetMenu(arg2);
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 resultobj = SWIG_Py_Void();
42062 return resultobj;
42063 fail:
42064 return NULL;
42065 }
42066
42067
42068 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42069 PyObject *resultobj = 0;
42070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42071 int arg2 ;
42072 void *argp1 = 0 ;
42073 int res1 = 0 ;
42074 int val2 ;
42075 int ecode2 = 0 ;
42076 PyObject * obj0 = 0 ;
42077 PyObject * obj1 = 0 ;
42078 char * kwnames[] = {
42079 (char *) "self",(char *) "id", NULL
42080 };
42081
42082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42084 if (!SWIG_IsOK(res1)) {
42085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42086 }
42087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42088 ecode2 = SWIG_AsVal_int(obj1, &val2);
42089 if (!SWIG_IsOK(ecode2)) {
42090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42091 }
42092 arg2 = static_cast< int >(val2);
42093 {
42094 PyThreadState* __tstate = wxPyBeginAllowThreads();
42095 (arg1)->SetId(arg2);
42096 wxPyEndAllowThreads(__tstate);
42097 if (PyErr_Occurred()) SWIG_fail;
42098 }
42099 resultobj = SWIG_Py_Void();
42100 return resultobj;
42101 fail:
42102 return NULL;
42103 }
42104
42105
42106 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42107 PyObject *resultobj = 0;
42108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42109 int result;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 PyObject *swig_obj[1] ;
42113
42114 if (!args) SWIG_fail;
42115 swig_obj[0] = args;
42116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42117 if (!SWIG_IsOK(res1)) {
42118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42119 }
42120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42121 {
42122 PyThreadState* __tstate = wxPyBeginAllowThreads();
42123 result = (int)((wxMenuItem const *)arg1)->GetId();
42124 wxPyEndAllowThreads(__tstate);
42125 if (PyErr_Occurred()) SWIG_fail;
42126 }
42127 resultobj = SWIG_From_int(static_cast< int >(result));
42128 return resultobj;
42129 fail:
42130 return NULL;
42131 }
42132
42133
42134 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42135 PyObject *resultobj = 0;
42136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42137 bool result;
42138 void *argp1 = 0 ;
42139 int res1 = 0 ;
42140 PyObject *swig_obj[1] ;
42141
42142 if (!args) SWIG_fail;
42143 swig_obj[0] = args;
42144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42145 if (!SWIG_IsOK(res1)) {
42146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42147 }
42148 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42149 {
42150 PyThreadState* __tstate = wxPyBeginAllowThreads();
42151 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42152 wxPyEndAllowThreads(__tstate);
42153 if (PyErr_Occurred()) SWIG_fail;
42154 }
42155 {
42156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42157 }
42158 return resultobj;
42159 fail:
42160 return NULL;
42161 }
42162
42163
42164 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42165 PyObject *resultobj = 0;
42166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42167 wxString *arg2 = 0 ;
42168 void *argp1 = 0 ;
42169 int res1 = 0 ;
42170 bool temp2 = false ;
42171 PyObject * obj0 = 0 ;
42172 PyObject * obj1 = 0 ;
42173 char * kwnames[] = {
42174 (char *) "self",(char *) "str", NULL
42175 };
42176
42177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42179 if (!SWIG_IsOK(res1)) {
42180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42181 }
42182 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42183 {
42184 arg2 = wxString_in_helper(obj1);
42185 if (arg2 == NULL) SWIG_fail;
42186 temp2 = true;
42187 }
42188 {
42189 PyThreadState* __tstate = wxPyBeginAllowThreads();
42190 (arg1)->SetText((wxString const &)*arg2);
42191 wxPyEndAllowThreads(__tstate);
42192 if (PyErr_Occurred()) SWIG_fail;
42193 }
42194 resultobj = SWIG_Py_Void();
42195 {
42196 if (temp2)
42197 delete arg2;
42198 }
42199 return resultobj;
42200 fail:
42201 {
42202 if (temp2)
42203 delete arg2;
42204 }
42205 return NULL;
42206 }
42207
42208
42209 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42210 PyObject *resultobj = 0;
42211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42212 wxString result;
42213 void *argp1 = 0 ;
42214 int res1 = 0 ;
42215 PyObject *swig_obj[1] ;
42216
42217 if (!args) SWIG_fail;
42218 swig_obj[0] = args;
42219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42220 if (!SWIG_IsOK(res1)) {
42221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42222 }
42223 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42224 {
42225 PyThreadState* __tstate = wxPyBeginAllowThreads();
42226 result = ((wxMenuItem const *)arg1)->GetLabel();
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 {
42231 #if wxUSE_UNICODE
42232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42233 #else
42234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42235 #endif
42236 }
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42244 PyObject *resultobj = 0;
42245 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42246 wxString *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_wxMenuItem, 0 | 0 );
42254 if (!SWIG_IsOK(res1)) {
42255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42256 }
42257 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 {
42261 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42262 result = (wxString *) &_result_ref;
42263 }
42264 wxPyEndAllowThreads(__tstate);
42265 if (PyErr_Occurred()) SWIG_fail;
42266 }
42267 {
42268 #if wxUSE_UNICODE
42269 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42270 #else
42271 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42272 #endif
42273 }
42274 return resultobj;
42275 fail:
42276 return NULL;
42277 }
42278
42279
42280 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42281 PyObject *resultobj = 0;
42282 wxString *arg1 = 0 ;
42283 wxString result;
42284 bool temp1 = false ;
42285 PyObject * obj0 = 0 ;
42286 char * kwnames[] = {
42287 (char *) "text", NULL
42288 };
42289
42290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42291 {
42292 arg1 = wxString_in_helper(obj0);
42293 if (arg1 == NULL) SWIG_fail;
42294 temp1 = true;
42295 }
42296 {
42297 PyThreadState* __tstate = wxPyBeginAllowThreads();
42298 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42299 wxPyEndAllowThreads(__tstate);
42300 if (PyErr_Occurred()) SWIG_fail;
42301 }
42302 {
42303 #if wxUSE_UNICODE
42304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42305 #else
42306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42307 #endif
42308 }
42309 {
42310 if (temp1)
42311 delete arg1;
42312 }
42313 return resultobj;
42314 fail:
42315 {
42316 if (temp1)
42317 delete arg1;
42318 }
42319 return NULL;
42320 }
42321
42322
42323 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42324 PyObject *resultobj = 0;
42325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42326 wxItemKind result;
42327 void *argp1 = 0 ;
42328 int res1 = 0 ;
42329 PyObject *swig_obj[1] ;
42330
42331 if (!args) SWIG_fail;
42332 swig_obj[0] = args;
42333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42334 if (!SWIG_IsOK(res1)) {
42335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42336 }
42337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42338 {
42339 PyThreadState* __tstate = wxPyBeginAllowThreads();
42340 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42341 wxPyEndAllowThreads(__tstate);
42342 if (PyErr_Occurred()) SWIG_fail;
42343 }
42344 resultobj = SWIG_From_int(static_cast< int >(result));
42345 return resultobj;
42346 fail:
42347 return NULL;
42348 }
42349
42350
42351 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42352 PyObject *resultobj = 0;
42353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42354 wxItemKind arg2 ;
42355 void *argp1 = 0 ;
42356 int res1 = 0 ;
42357 int val2 ;
42358 int ecode2 = 0 ;
42359 PyObject * obj0 = 0 ;
42360 PyObject * obj1 = 0 ;
42361 char * kwnames[] = {
42362 (char *) "self",(char *) "kind", NULL
42363 };
42364
42365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42367 if (!SWIG_IsOK(res1)) {
42368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42369 }
42370 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42371 ecode2 = SWIG_AsVal_int(obj1, &val2);
42372 if (!SWIG_IsOK(ecode2)) {
42373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42374 }
42375 arg2 = static_cast< wxItemKind >(val2);
42376 {
42377 PyThreadState* __tstate = wxPyBeginAllowThreads();
42378 (arg1)->SetKind(arg2);
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 resultobj = SWIG_Py_Void();
42383 return resultobj;
42384 fail:
42385 return NULL;
42386 }
42387
42388
42389 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42390 PyObject *resultobj = 0;
42391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42392 bool arg2 ;
42393 void *argp1 = 0 ;
42394 int res1 = 0 ;
42395 bool val2 ;
42396 int ecode2 = 0 ;
42397 PyObject * obj0 = 0 ;
42398 PyObject * obj1 = 0 ;
42399 char * kwnames[] = {
42400 (char *) "self",(char *) "checkable", NULL
42401 };
42402
42403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42405 if (!SWIG_IsOK(res1)) {
42406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42407 }
42408 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42409 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42410 if (!SWIG_IsOK(ecode2)) {
42411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42412 }
42413 arg2 = static_cast< bool >(val2);
42414 {
42415 PyThreadState* __tstate = wxPyBeginAllowThreads();
42416 (arg1)->SetCheckable(arg2);
42417 wxPyEndAllowThreads(__tstate);
42418 if (PyErr_Occurred()) SWIG_fail;
42419 }
42420 resultobj = SWIG_Py_Void();
42421 return resultobj;
42422 fail:
42423 return NULL;
42424 }
42425
42426
42427 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42428 PyObject *resultobj = 0;
42429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42430 bool result;
42431 void *argp1 = 0 ;
42432 int res1 = 0 ;
42433 PyObject *swig_obj[1] ;
42434
42435 if (!args) SWIG_fail;
42436 swig_obj[0] = args;
42437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42438 if (!SWIG_IsOK(res1)) {
42439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42440 }
42441 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42442 {
42443 PyThreadState* __tstate = wxPyBeginAllowThreads();
42444 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42445 wxPyEndAllowThreads(__tstate);
42446 if (PyErr_Occurred()) SWIG_fail;
42447 }
42448 {
42449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42450 }
42451 return resultobj;
42452 fail:
42453 return NULL;
42454 }
42455
42456
42457 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42458 PyObject *resultobj = 0;
42459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42460 bool result;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 PyObject *swig_obj[1] ;
42464
42465 if (!args) SWIG_fail;
42466 swig_obj[0] = args;
42467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42468 if (!SWIG_IsOK(res1)) {
42469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42470 }
42471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 {
42479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42480 }
42481 return resultobj;
42482 fail:
42483 return NULL;
42484 }
42485
42486
42487 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42488 PyObject *resultobj = 0;
42489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42490 wxMenu *arg2 = (wxMenu *) 0 ;
42491 void *argp1 = 0 ;
42492 int res1 = 0 ;
42493 void *argp2 = 0 ;
42494 int res2 = 0 ;
42495 PyObject * obj0 = 0 ;
42496 PyObject * obj1 = 0 ;
42497 char * kwnames[] = {
42498 (char *) "self",(char *) "menu", NULL
42499 };
42500
42501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42503 if (!SWIG_IsOK(res1)) {
42504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42505 }
42506 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42507 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42508 if (!SWIG_IsOK(res2)) {
42509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42510 }
42511 arg2 = reinterpret_cast< wxMenu * >(argp2);
42512 {
42513 PyThreadState* __tstate = wxPyBeginAllowThreads();
42514 (arg1)->SetSubMenu(arg2);
42515 wxPyEndAllowThreads(__tstate);
42516 if (PyErr_Occurred()) SWIG_fail;
42517 }
42518 resultobj = SWIG_Py_Void();
42519 return resultobj;
42520 fail:
42521 return NULL;
42522 }
42523
42524
42525 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42526 PyObject *resultobj = 0;
42527 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42528 wxMenu *result = 0 ;
42529 void *argp1 = 0 ;
42530 int res1 = 0 ;
42531 PyObject *swig_obj[1] ;
42532
42533 if (!args) SWIG_fail;
42534 swig_obj[0] = args;
42535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42536 if (!SWIG_IsOK(res1)) {
42537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42538 }
42539 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42540 {
42541 PyThreadState* __tstate = wxPyBeginAllowThreads();
42542 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42543 wxPyEndAllowThreads(__tstate);
42544 if (PyErr_Occurred()) SWIG_fail;
42545 }
42546 {
42547 resultobj = wxPyMake_wxObject(result, 0);
42548 }
42549 return resultobj;
42550 fail:
42551 return NULL;
42552 }
42553
42554
42555 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42556 PyObject *resultobj = 0;
42557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42558 bool arg2 = (bool) true ;
42559 void *argp1 = 0 ;
42560 int res1 = 0 ;
42561 bool val2 ;
42562 int ecode2 = 0 ;
42563 PyObject * obj0 = 0 ;
42564 PyObject * obj1 = 0 ;
42565 char * kwnames[] = {
42566 (char *) "self",(char *) "enable", NULL
42567 };
42568
42569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42571 if (!SWIG_IsOK(res1)) {
42572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42573 }
42574 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42575 if (obj1) {
42576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42577 if (!SWIG_IsOK(ecode2)) {
42578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42579 }
42580 arg2 = static_cast< bool >(val2);
42581 }
42582 {
42583 PyThreadState* __tstate = wxPyBeginAllowThreads();
42584 (arg1)->Enable(arg2);
42585 wxPyEndAllowThreads(__tstate);
42586 if (PyErr_Occurred()) SWIG_fail;
42587 }
42588 resultobj = SWIG_Py_Void();
42589 return resultobj;
42590 fail:
42591 return NULL;
42592 }
42593
42594
42595 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42596 PyObject *resultobj = 0;
42597 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42598 bool result;
42599 void *argp1 = 0 ;
42600 int res1 = 0 ;
42601 PyObject *swig_obj[1] ;
42602
42603 if (!args) SWIG_fail;
42604 swig_obj[0] = args;
42605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42606 if (!SWIG_IsOK(res1)) {
42607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42608 }
42609 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42610 {
42611 PyThreadState* __tstate = wxPyBeginAllowThreads();
42612 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42613 wxPyEndAllowThreads(__tstate);
42614 if (PyErr_Occurred()) SWIG_fail;
42615 }
42616 {
42617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42618 }
42619 return resultobj;
42620 fail:
42621 return NULL;
42622 }
42623
42624
42625 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42626 PyObject *resultobj = 0;
42627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42628 bool arg2 = (bool) true ;
42629 void *argp1 = 0 ;
42630 int res1 = 0 ;
42631 bool val2 ;
42632 int ecode2 = 0 ;
42633 PyObject * obj0 = 0 ;
42634 PyObject * obj1 = 0 ;
42635 char * kwnames[] = {
42636 (char *) "self",(char *) "check", NULL
42637 };
42638
42639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42641 if (!SWIG_IsOK(res1)) {
42642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42643 }
42644 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42645 if (obj1) {
42646 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42647 if (!SWIG_IsOK(ecode2)) {
42648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42649 }
42650 arg2 = static_cast< bool >(val2);
42651 }
42652 {
42653 PyThreadState* __tstate = wxPyBeginAllowThreads();
42654 (arg1)->Check(arg2);
42655 wxPyEndAllowThreads(__tstate);
42656 if (PyErr_Occurred()) SWIG_fail;
42657 }
42658 resultobj = SWIG_Py_Void();
42659 return resultobj;
42660 fail:
42661 return NULL;
42662 }
42663
42664
42665 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42666 PyObject *resultobj = 0;
42667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42668 bool result;
42669 void *argp1 = 0 ;
42670 int res1 = 0 ;
42671 PyObject *swig_obj[1] ;
42672
42673 if (!args) SWIG_fail;
42674 swig_obj[0] = args;
42675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42676 if (!SWIG_IsOK(res1)) {
42677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42678 }
42679 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42680 {
42681 PyThreadState* __tstate = wxPyBeginAllowThreads();
42682 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42683 wxPyEndAllowThreads(__tstate);
42684 if (PyErr_Occurred()) SWIG_fail;
42685 }
42686 {
42687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42688 }
42689 return resultobj;
42690 fail:
42691 return NULL;
42692 }
42693
42694
42695 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42696 PyObject *resultobj = 0;
42697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42698 void *argp1 = 0 ;
42699 int res1 = 0 ;
42700 PyObject *swig_obj[1] ;
42701
42702 if (!args) SWIG_fail;
42703 swig_obj[0] = args;
42704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42705 if (!SWIG_IsOK(res1)) {
42706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42707 }
42708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42709 {
42710 PyThreadState* __tstate = wxPyBeginAllowThreads();
42711 (arg1)->Toggle();
42712 wxPyEndAllowThreads(__tstate);
42713 if (PyErr_Occurred()) SWIG_fail;
42714 }
42715 resultobj = SWIG_Py_Void();
42716 return resultobj;
42717 fail:
42718 return NULL;
42719 }
42720
42721
42722 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42723 PyObject *resultobj = 0;
42724 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42725 wxString *arg2 = 0 ;
42726 void *argp1 = 0 ;
42727 int res1 = 0 ;
42728 bool temp2 = false ;
42729 PyObject * obj0 = 0 ;
42730 PyObject * obj1 = 0 ;
42731 char * kwnames[] = {
42732 (char *) "self",(char *) "str", NULL
42733 };
42734
42735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42737 if (!SWIG_IsOK(res1)) {
42738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42739 }
42740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42741 {
42742 arg2 = wxString_in_helper(obj1);
42743 if (arg2 == NULL) SWIG_fail;
42744 temp2 = true;
42745 }
42746 {
42747 PyThreadState* __tstate = wxPyBeginAllowThreads();
42748 (arg1)->SetHelp((wxString const &)*arg2);
42749 wxPyEndAllowThreads(__tstate);
42750 if (PyErr_Occurred()) SWIG_fail;
42751 }
42752 resultobj = SWIG_Py_Void();
42753 {
42754 if (temp2)
42755 delete arg2;
42756 }
42757 return resultobj;
42758 fail:
42759 {
42760 if (temp2)
42761 delete arg2;
42762 }
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42768 PyObject *resultobj = 0;
42769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42770 wxString *result = 0 ;
42771 void *argp1 = 0 ;
42772 int res1 = 0 ;
42773 PyObject *swig_obj[1] ;
42774
42775 if (!args) SWIG_fail;
42776 swig_obj[0] = args;
42777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42778 if (!SWIG_IsOK(res1)) {
42779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42780 }
42781 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42782 {
42783 PyThreadState* __tstate = wxPyBeginAllowThreads();
42784 {
42785 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42786 result = (wxString *) &_result_ref;
42787 }
42788 wxPyEndAllowThreads(__tstate);
42789 if (PyErr_Occurred()) SWIG_fail;
42790 }
42791 {
42792 #if wxUSE_UNICODE
42793 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42794 #else
42795 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42796 #endif
42797 }
42798 return resultobj;
42799 fail:
42800 return NULL;
42801 }
42802
42803
42804 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42805 PyObject *resultobj = 0;
42806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42807 wxAcceleratorEntry *result = 0 ;
42808 void *argp1 = 0 ;
42809 int res1 = 0 ;
42810 PyObject *swig_obj[1] ;
42811
42812 if (!args) SWIG_fail;
42813 swig_obj[0] = args;
42814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42815 if (!SWIG_IsOK(res1)) {
42816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42817 }
42818 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42819 {
42820 PyThreadState* __tstate = wxPyBeginAllowThreads();
42821 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42822 wxPyEndAllowThreads(__tstate);
42823 if (PyErr_Occurred()) SWIG_fail;
42824 }
42825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42826 return resultobj;
42827 fail:
42828 return NULL;
42829 }
42830
42831
42832 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42833 PyObject *resultobj = 0;
42834 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42835 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42836 void *argp1 = 0 ;
42837 int res1 = 0 ;
42838 void *argp2 = 0 ;
42839 int res2 = 0 ;
42840 PyObject * obj0 = 0 ;
42841 PyObject * obj1 = 0 ;
42842 char * kwnames[] = {
42843 (char *) "self",(char *) "accel", NULL
42844 };
42845
42846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42848 if (!SWIG_IsOK(res1)) {
42849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42850 }
42851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42853 if (!SWIG_IsOK(res2)) {
42854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42855 }
42856 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42857 {
42858 PyThreadState* __tstate = wxPyBeginAllowThreads();
42859 (arg1)->SetAccel(arg2);
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 resultobj = SWIG_Py_Void();
42864 return resultobj;
42865 fail:
42866 return NULL;
42867 }
42868
42869
42870 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42871 PyObject *resultobj = 0;
42872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42873 wxBitmap *arg2 = 0 ;
42874 void *argp1 = 0 ;
42875 int res1 = 0 ;
42876 void *argp2 = 0 ;
42877 int res2 = 0 ;
42878 PyObject * obj0 = 0 ;
42879 PyObject * obj1 = 0 ;
42880 char * kwnames[] = {
42881 (char *) "self",(char *) "bitmap", NULL
42882 };
42883
42884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42886 if (!SWIG_IsOK(res1)) {
42887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42888 }
42889 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42890 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42891 if (!SWIG_IsOK(res2)) {
42892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42893 }
42894 if (!argp2) {
42895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42896 }
42897 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42898 {
42899 PyThreadState* __tstate = wxPyBeginAllowThreads();
42900 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42901 wxPyEndAllowThreads(__tstate);
42902 if (PyErr_Occurred()) SWIG_fail;
42903 }
42904 resultobj = SWIG_Py_Void();
42905 return resultobj;
42906 fail:
42907 return NULL;
42908 }
42909
42910
42911 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42912 PyObject *resultobj = 0;
42913 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42914 wxBitmap *result = 0 ;
42915 void *argp1 = 0 ;
42916 int res1 = 0 ;
42917 PyObject *swig_obj[1] ;
42918
42919 if (!args) SWIG_fail;
42920 swig_obj[0] = args;
42921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42922 if (!SWIG_IsOK(res1)) {
42923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42924 }
42925 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42926 {
42927 PyThreadState* __tstate = wxPyBeginAllowThreads();
42928 {
42929 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42930 result = (wxBitmap *) &_result_ref;
42931 }
42932 wxPyEndAllowThreads(__tstate);
42933 if (PyErr_Occurred()) SWIG_fail;
42934 }
42935 {
42936 wxBitmap* resultptr = new wxBitmap(*result);
42937 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42938 }
42939 return resultobj;
42940 fail:
42941 return NULL;
42942 }
42943
42944
42945 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42946 PyObject *resultobj = 0;
42947 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42948 wxFont *arg2 = 0 ;
42949 void *argp1 = 0 ;
42950 int res1 = 0 ;
42951 void *argp2 = 0 ;
42952 int res2 = 0 ;
42953 PyObject * obj0 = 0 ;
42954 PyObject * obj1 = 0 ;
42955 char * kwnames[] = {
42956 (char *) "self",(char *) "font", NULL
42957 };
42958
42959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42961 if (!SWIG_IsOK(res1)) {
42962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42963 }
42964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42965 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42966 if (!SWIG_IsOK(res2)) {
42967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42968 }
42969 if (!argp2) {
42970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42971 }
42972 arg2 = reinterpret_cast< wxFont * >(argp2);
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 resultobj = SWIG_Py_Void();
42980 return resultobj;
42981 fail:
42982 return NULL;
42983 }
42984
42985
42986 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42987 PyObject *resultobj = 0;
42988 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42989 wxFont result;
42990 void *argp1 = 0 ;
42991 int res1 = 0 ;
42992 PyObject *swig_obj[1] ;
42993
42994 if (!args) SWIG_fail;
42995 swig_obj[0] = args;
42996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42997 if (!SWIG_IsOK(res1)) {
42998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42999 }
43000 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43001 {
43002 PyThreadState* __tstate = wxPyBeginAllowThreads();
43003 result = wxMenuItem_GetFont(arg1);
43004 wxPyEndAllowThreads(__tstate);
43005 if (PyErr_Occurred()) SWIG_fail;
43006 }
43007 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43008 return resultobj;
43009 fail:
43010 return NULL;
43011 }
43012
43013
43014 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43015 PyObject *resultobj = 0;
43016 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43017 wxColour *arg2 = 0 ;
43018 void *argp1 = 0 ;
43019 int res1 = 0 ;
43020 wxColour temp2 ;
43021 PyObject * obj0 = 0 ;
43022 PyObject * obj1 = 0 ;
43023 char * kwnames[] = {
43024 (char *) "self",(char *) "colText", NULL
43025 };
43026
43027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43029 if (!SWIG_IsOK(res1)) {
43030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43031 }
43032 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43033 {
43034 arg2 = &temp2;
43035 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43036 }
43037 {
43038 PyThreadState* __tstate = wxPyBeginAllowThreads();
43039 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 resultobj = SWIG_Py_Void();
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43051 PyObject *resultobj = 0;
43052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43053 wxColour result;
43054 void *argp1 = 0 ;
43055 int res1 = 0 ;
43056 PyObject *swig_obj[1] ;
43057
43058 if (!args) SWIG_fail;
43059 swig_obj[0] = args;
43060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43061 if (!SWIG_IsOK(res1)) {
43062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43063 }
43064 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43065 {
43066 PyThreadState* __tstate = wxPyBeginAllowThreads();
43067 result = wxMenuItem_GetTextColour(arg1);
43068 wxPyEndAllowThreads(__tstate);
43069 if (PyErr_Occurred()) SWIG_fail;
43070 }
43071 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43072 return resultobj;
43073 fail:
43074 return NULL;
43075 }
43076
43077
43078 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43079 PyObject *resultobj = 0;
43080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43081 wxColour *arg2 = 0 ;
43082 void *argp1 = 0 ;
43083 int res1 = 0 ;
43084 wxColour temp2 ;
43085 PyObject * obj0 = 0 ;
43086 PyObject * obj1 = 0 ;
43087 char * kwnames[] = {
43088 (char *) "self",(char *) "colBack", NULL
43089 };
43090
43091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43093 if (!SWIG_IsOK(res1)) {
43094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43095 }
43096 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43097 {
43098 arg2 = &temp2;
43099 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43100 }
43101 {
43102 PyThreadState* __tstate = wxPyBeginAllowThreads();
43103 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43104 wxPyEndAllowThreads(__tstate);
43105 if (PyErr_Occurred()) SWIG_fail;
43106 }
43107 resultobj = SWIG_Py_Void();
43108 return resultobj;
43109 fail:
43110 return NULL;
43111 }
43112
43113
43114 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43115 PyObject *resultobj = 0;
43116 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43117 wxColour result;
43118 void *argp1 = 0 ;
43119 int res1 = 0 ;
43120 PyObject *swig_obj[1] ;
43121
43122 if (!args) SWIG_fail;
43123 swig_obj[0] = args;
43124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43125 if (!SWIG_IsOK(res1)) {
43126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43127 }
43128 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43129 {
43130 PyThreadState* __tstate = wxPyBeginAllowThreads();
43131 result = wxMenuItem_GetBackgroundColour(arg1);
43132 wxPyEndAllowThreads(__tstate);
43133 if (PyErr_Occurred()) SWIG_fail;
43134 }
43135 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43136 return resultobj;
43137 fail:
43138 return NULL;
43139 }
43140
43141
43142 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43143 PyObject *resultobj = 0;
43144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43145 wxBitmap *arg2 = 0 ;
43146 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43147 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43148 void *argp1 = 0 ;
43149 int res1 = 0 ;
43150 void *argp2 = 0 ;
43151 int res2 = 0 ;
43152 void *argp3 = 0 ;
43153 int res3 = 0 ;
43154 PyObject * obj0 = 0 ;
43155 PyObject * obj1 = 0 ;
43156 PyObject * obj2 = 0 ;
43157 char * kwnames[] = {
43158 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43159 };
43160
43161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43163 if (!SWIG_IsOK(res1)) {
43164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43165 }
43166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43167 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43168 if (!SWIG_IsOK(res2)) {
43169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43170 }
43171 if (!argp2) {
43172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43173 }
43174 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43175 if (obj2) {
43176 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43177 if (!SWIG_IsOK(res3)) {
43178 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43179 }
43180 if (!argp3) {
43181 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43182 }
43183 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43184 }
43185 {
43186 PyThreadState* __tstate = wxPyBeginAllowThreads();
43187 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43188 wxPyEndAllowThreads(__tstate);
43189 if (PyErr_Occurred()) SWIG_fail;
43190 }
43191 resultobj = SWIG_Py_Void();
43192 return resultobj;
43193 fail:
43194 return NULL;
43195 }
43196
43197
43198 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43199 PyObject *resultobj = 0;
43200 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43201 wxBitmap *arg2 = 0 ;
43202 void *argp1 = 0 ;
43203 int res1 = 0 ;
43204 void *argp2 = 0 ;
43205 int res2 = 0 ;
43206 PyObject * obj0 = 0 ;
43207 PyObject * obj1 = 0 ;
43208 char * kwnames[] = {
43209 (char *) "self",(char *) "bmpDisabled", NULL
43210 };
43211
43212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43214 if (!SWIG_IsOK(res1)) {
43215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43216 }
43217 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43218 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43219 if (!SWIG_IsOK(res2)) {
43220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43221 }
43222 if (!argp2) {
43223 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43224 }
43225 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43226 {
43227 PyThreadState* __tstate = wxPyBeginAllowThreads();
43228 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43229 wxPyEndAllowThreads(__tstate);
43230 if (PyErr_Occurred()) SWIG_fail;
43231 }
43232 resultobj = SWIG_Py_Void();
43233 return resultobj;
43234 fail:
43235 return NULL;
43236 }
43237
43238
43239 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43240 PyObject *resultobj = 0;
43241 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43242 wxBitmap *result = 0 ;
43243 void *argp1 = 0 ;
43244 int res1 = 0 ;
43245 PyObject *swig_obj[1] ;
43246
43247 if (!args) SWIG_fail;
43248 swig_obj[0] = args;
43249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43250 if (!SWIG_IsOK(res1)) {
43251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43252 }
43253 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43254 {
43255 PyThreadState* __tstate = wxPyBeginAllowThreads();
43256 {
43257 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43258 result = (wxBitmap *) &_result_ref;
43259 }
43260 wxPyEndAllowThreads(__tstate);
43261 if (PyErr_Occurred()) SWIG_fail;
43262 }
43263 {
43264 wxBitmap* resultptr = new wxBitmap(*result);
43265 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43266 }
43267 return resultobj;
43268 fail:
43269 return NULL;
43270 }
43271
43272
43273 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43274 PyObject *resultobj = 0;
43275 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43276 int arg2 ;
43277 void *argp1 = 0 ;
43278 int res1 = 0 ;
43279 int val2 ;
43280 int ecode2 = 0 ;
43281 PyObject * obj0 = 0 ;
43282 PyObject * obj1 = 0 ;
43283 char * kwnames[] = {
43284 (char *) "self",(char *) "nWidth", NULL
43285 };
43286
43287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43289 if (!SWIG_IsOK(res1)) {
43290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43291 }
43292 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43293 ecode2 = SWIG_AsVal_int(obj1, &val2);
43294 if (!SWIG_IsOK(ecode2)) {
43295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43296 }
43297 arg2 = static_cast< int >(val2);
43298 {
43299 PyThreadState* __tstate = wxPyBeginAllowThreads();
43300 wxMenuItem_SetMarginWidth(arg1,arg2);
43301 wxPyEndAllowThreads(__tstate);
43302 if (PyErr_Occurred()) SWIG_fail;
43303 }
43304 resultobj = SWIG_Py_Void();
43305 return resultobj;
43306 fail:
43307 return NULL;
43308 }
43309
43310
43311 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43312 PyObject *resultobj = 0;
43313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43314 int result;
43315 void *argp1 = 0 ;
43316 int res1 = 0 ;
43317 PyObject *swig_obj[1] ;
43318
43319 if (!args) SWIG_fail;
43320 swig_obj[0] = args;
43321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43322 if (!SWIG_IsOK(res1)) {
43323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43324 }
43325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43326 {
43327 PyThreadState* __tstate = wxPyBeginAllowThreads();
43328 result = (int)wxMenuItem_GetMarginWidth(arg1);
43329 wxPyEndAllowThreads(__tstate);
43330 if (PyErr_Occurred()) SWIG_fail;
43331 }
43332 resultobj = SWIG_From_int(static_cast< int >(result));
43333 return resultobj;
43334 fail:
43335 return NULL;
43336 }
43337
43338
43339 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43340 PyObject *resultobj = 0;
43341 int result;
43342
43343 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43344 {
43345 PyThreadState* __tstate = wxPyBeginAllowThreads();
43346 result = (int)wxMenuItem_GetDefaultMarginWidth();
43347 wxPyEndAllowThreads(__tstate);
43348 if (PyErr_Occurred()) SWIG_fail;
43349 }
43350 resultobj = SWIG_From_int(static_cast< int >(result));
43351 return resultobj;
43352 fail:
43353 return NULL;
43354 }
43355
43356
43357 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43358 PyObject *resultobj = 0;
43359 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43360 bool result;
43361 void *argp1 = 0 ;
43362 int res1 = 0 ;
43363 PyObject *swig_obj[1] ;
43364
43365 if (!args) SWIG_fail;
43366 swig_obj[0] = args;
43367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43368 if (!SWIG_IsOK(res1)) {
43369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43370 }
43371 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43372 {
43373 PyThreadState* __tstate = wxPyBeginAllowThreads();
43374 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43375 wxPyEndAllowThreads(__tstate);
43376 if (PyErr_Occurred()) SWIG_fail;
43377 }
43378 {
43379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43380 }
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43388 PyObject *resultobj = 0;
43389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43390 bool arg2 = (bool) true ;
43391 void *argp1 = 0 ;
43392 int res1 = 0 ;
43393 bool val2 ;
43394 int ecode2 = 0 ;
43395 PyObject * obj0 = 0 ;
43396 PyObject * obj1 = 0 ;
43397 char * kwnames[] = {
43398 (char *) "self",(char *) "ownerDrawn", NULL
43399 };
43400
43401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43403 if (!SWIG_IsOK(res1)) {
43404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43405 }
43406 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43407 if (obj1) {
43408 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43409 if (!SWIG_IsOK(ecode2)) {
43410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43411 }
43412 arg2 = static_cast< bool >(val2);
43413 }
43414 {
43415 PyThreadState* __tstate = wxPyBeginAllowThreads();
43416 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43417 wxPyEndAllowThreads(__tstate);
43418 if (PyErr_Occurred()) SWIG_fail;
43419 }
43420 resultobj = SWIG_Py_Void();
43421 return resultobj;
43422 fail:
43423 return NULL;
43424 }
43425
43426
43427 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43428 PyObject *resultobj = 0;
43429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43430 void *argp1 = 0 ;
43431 int res1 = 0 ;
43432 PyObject *swig_obj[1] ;
43433
43434 if (!args) SWIG_fail;
43435 swig_obj[0] = args;
43436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43437 if (!SWIG_IsOK(res1)) {
43438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43439 }
43440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43441 {
43442 PyThreadState* __tstate = wxPyBeginAllowThreads();
43443 wxMenuItem_ResetOwnerDrawn(arg1);
43444 wxPyEndAllowThreads(__tstate);
43445 if (PyErr_Occurred()) SWIG_fail;
43446 }
43447 resultobj = SWIG_Py_Void();
43448 return resultobj;
43449 fail:
43450 return NULL;
43451 }
43452
43453
43454 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43455 PyObject *obj;
43456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43457 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43458 return SWIG_Py_Void();
43459 }
43460
43461 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43462 return SWIG_Python_InitShadowInstance(args);
43463 }
43464
43465 SWIGINTERN int ControlNameStr_set(PyObject *) {
43466 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43467 return 1;
43468 }
43469
43470
43471 SWIGINTERN PyObject *ControlNameStr_get(void) {
43472 PyObject *pyobj = 0;
43473
43474 {
43475 #if wxUSE_UNICODE
43476 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43477 #else
43478 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43479 #endif
43480 }
43481 return pyobj;
43482 }
43483
43484
43485 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43486 PyObject *resultobj = 0;
43487 wxWindow *arg1 = (wxWindow *) 0 ;
43488 int arg2 = (int) -1 ;
43489 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43490 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43491 wxSize const &arg4_defvalue = wxDefaultSize ;
43492 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43493 long arg5 = (long) 0 ;
43494 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43495 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43496 wxString const &arg7_defvalue = wxPyControlNameStr ;
43497 wxString *arg7 = (wxString *) &arg7_defvalue ;
43498 wxControl *result = 0 ;
43499 void *argp1 = 0 ;
43500 int res1 = 0 ;
43501 int val2 ;
43502 int ecode2 = 0 ;
43503 wxPoint temp3 ;
43504 wxSize temp4 ;
43505 long val5 ;
43506 int ecode5 = 0 ;
43507 void *argp6 = 0 ;
43508 int res6 = 0 ;
43509 bool temp7 = false ;
43510 PyObject * obj0 = 0 ;
43511 PyObject * obj1 = 0 ;
43512 PyObject * obj2 = 0 ;
43513 PyObject * obj3 = 0 ;
43514 PyObject * obj4 = 0 ;
43515 PyObject * obj5 = 0 ;
43516 PyObject * obj6 = 0 ;
43517 char * kwnames[] = {
43518 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43519 };
43520
43521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43523 if (!SWIG_IsOK(res1)) {
43524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43525 }
43526 arg1 = reinterpret_cast< wxWindow * >(argp1);
43527 if (obj1) {
43528 ecode2 = SWIG_AsVal_int(obj1, &val2);
43529 if (!SWIG_IsOK(ecode2)) {
43530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43531 }
43532 arg2 = static_cast< int >(val2);
43533 }
43534 if (obj2) {
43535 {
43536 arg3 = &temp3;
43537 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43538 }
43539 }
43540 if (obj3) {
43541 {
43542 arg4 = &temp4;
43543 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43544 }
43545 }
43546 if (obj4) {
43547 ecode5 = SWIG_AsVal_long(obj4, &val5);
43548 if (!SWIG_IsOK(ecode5)) {
43549 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43550 }
43551 arg5 = static_cast< long >(val5);
43552 }
43553 if (obj5) {
43554 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43555 if (!SWIG_IsOK(res6)) {
43556 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43557 }
43558 if (!argp6) {
43559 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43560 }
43561 arg6 = reinterpret_cast< wxValidator * >(argp6);
43562 }
43563 if (obj6) {
43564 {
43565 arg7 = wxString_in_helper(obj6);
43566 if (arg7 == NULL) SWIG_fail;
43567 temp7 = true;
43568 }
43569 }
43570 {
43571 if (!wxPyCheckForApp()) SWIG_fail;
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43578 {
43579 if (temp7)
43580 delete arg7;
43581 }
43582 return resultobj;
43583 fail:
43584 {
43585 if (temp7)
43586 delete arg7;
43587 }
43588 return NULL;
43589 }
43590
43591
43592 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43593 PyObject *resultobj = 0;
43594 wxControl *result = 0 ;
43595
43596 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43597 {
43598 if (!wxPyCheckForApp()) SWIG_fail;
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 result = (wxControl *)new wxControl();
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43605 return resultobj;
43606 fail:
43607 return NULL;
43608 }
43609
43610
43611 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43612 PyObject *resultobj = 0;
43613 wxControl *arg1 = (wxControl *) 0 ;
43614 wxWindow *arg2 = (wxWindow *) 0 ;
43615 int arg3 = (int) -1 ;
43616 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43617 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43618 wxSize const &arg5_defvalue = wxDefaultSize ;
43619 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43620 long arg6 = (long) 0 ;
43621 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43622 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43623 wxString const &arg8_defvalue = wxPyControlNameStr ;
43624 wxString *arg8 = (wxString *) &arg8_defvalue ;
43625 bool result;
43626 void *argp1 = 0 ;
43627 int res1 = 0 ;
43628 void *argp2 = 0 ;
43629 int res2 = 0 ;
43630 int val3 ;
43631 int ecode3 = 0 ;
43632 wxPoint temp4 ;
43633 wxSize temp5 ;
43634 long val6 ;
43635 int ecode6 = 0 ;
43636 void *argp7 = 0 ;
43637 int res7 = 0 ;
43638 bool temp8 = false ;
43639 PyObject * obj0 = 0 ;
43640 PyObject * obj1 = 0 ;
43641 PyObject * obj2 = 0 ;
43642 PyObject * obj3 = 0 ;
43643 PyObject * obj4 = 0 ;
43644 PyObject * obj5 = 0 ;
43645 PyObject * obj6 = 0 ;
43646 PyObject * obj7 = 0 ;
43647 char * kwnames[] = {
43648 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43649 };
43650
43651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43653 if (!SWIG_IsOK(res1)) {
43654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43655 }
43656 arg1 = reinterpret_cast< wxControl * >(argp1);
43657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43658 if (!SWIG_IsOK(res2)) {
43659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43660 }
43661 arg2 = reinterpret_cast< wxWindow * >(argp2);
43662 if (obj2) {
43663 ecode3 = SWIG_AsVal_int(obj2, &val3);
43664 if (!SWIG_IsOK(ecode3)) {
43665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43666 }
43667 arg3 = static_cast< int >(val3);
43668 }
43669 if (obj3) {
43670 {
43671 arg4 = &temp4;
43672 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43673 }
43674 }
43675 if (obj4) {
43676 {
43677 arg5 = &temp5;
43678 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43679 }
43680 }
43681 if (obj5) {
43682 ecode6 = SWIG_AsVal_long(obj5, &val6);
43683 if (!SWIG_IsOK(ecode6)) {
43684 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43685 }
43686 arg6 = static_cast< long >(val6);
43687 }
43688 if (obj6) {
43689 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43690 if (!SWIG_IsOK(res7)) {
43691 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43692 }
43693 if (!argp7) {
43694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43695 }
43696 arg7 = reinterpret_cast< wxValidator * >(argp7);
43697 }
43698 if (obj7) {
43699 {
43700 arg8 = wxString_in_helper(obj7);
43701 if (arg8 == NULL) SWIG_fail;
43702 temp8 = true;
43703 }
43704 }
43705 {
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43708 wxPyEndAllowThreads(__tstate);
43709 if (PyErr_Occurred()) SWIG_fail;
43710 }
43711 {
43712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43713 }
43714 {
43715 if (temp8)
43716 delete arg8;
43717 }
43718 return resultobj;
43719 fail:
43720 {
43721 if (temp8)
43722 delete arg8;
43723 }
43724 return NULL;
43725 }
43726
43727
43728 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43729 PyObject *resultobj = 0;
43730 wxControl *arg1 = (wxControl *) 0 ;
43731 wxCommandEvent *arg2 = 0 ;
43732 void *argp1 = 0 ;
43733 int res1 = 0 ;
43734 void *argp2 = 0 ;
43735 int res2 = 0 ;
43736 PyObject * obj0 = 0 ;
43737 PyObject * obj1 = 0 ;
43738 char * kwnames[] = {
43739 (char *) "self",(char *) "event", NULL
43740 };
43741
43742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43744 if (!SWIG_IsOK(res1)) {
43745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43746 }
43747 arg1 = reinterpret_cast< wxControl * >(argp1);
43748 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43749 if (!SWIG_IsOK(res2)) {
43750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43751 }
43752 if (!argp2) {
43753 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43754 }
43755 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43756 {
43757 PyThreadState* __tstate = wxPyBeginAllowThreads();
43758 (arg1)->Command(*arg2);
43759 wxPyEndAllowThreads(__tstate);
43760 if (PyErr_Occurred()) SWIG_fail;
43761 }
43762 resultobj = SWIG_Py_Void();
43763 return resultobj;
43764 fail:
43765 return NULL;
43766 }
43767
43768
43769 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43770 PyObject *resultobj = 0;
43771 wxControl *arg1 = (wxControl *) 0 ;
43772 wxString result;
43773 void *argp1 = 0 ;
43774 int res1 = 0 ;
43775 PyObject *swig_obj[1] ;
43776
43777 if (!args) SWIG_fail;
43778 swig_obj[0] = args;
43779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43780 if (!SWIG_IsOK(res1)) {
43781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43782 }
43783 arg1 = reinterpret_cast< wxControl * >(argp1);
43784 {
43785 PyThreadState* __tstate = wxPyBeginAllowThreads();
43786 result = (arg1)->GetLabel();
43787 wxPyEndAllowThreads(__tstate);
43788 if (PyErr_Occurred()) SWIG_fail;
43789 }
43790 {
43791 #if wxUSE_UNICODE
43792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43793 #else
43794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43795 #endif
43796 }
43797 return resultobj;
43798 fail:
43799 return NULL;
43800 }
43801
43802
43803 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43804 PyObject *resultobj = 0;
43805 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43806 SwigValueWrapper<wxVisualAttributes > result;
43807 int val1 ;
43808 int ecode1 = 0 ;
43809 PyObject * obj0 = 0 ;
43810 char * kwnames[] = {
43811 (char *) "variant", NULL
43812 };
43813
43814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43815 if (obj0) {
43816 ecode1 = SWIG_AsVal_int(obj0, &val1);
43817 if (!SWIG_IsOK(ecode1)) {
43818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43819 }
43820 arg1 = static_cast< wxWindowVariant >(val1);
43821 }
43822 {
43823 if (!wxPyCheckForApp()) SWIG_fail;
43824 PyThreadState* __tstate = wxPyBeginAllowThreads();
43825 result = wxControl::GetClassDefaultAttributes(arg1);
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43830 return resultobj;
43831 fail:
43832 return NULL;
43833 }
43834
43835
43836 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43837 PyObject *obj;
43838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43839 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43840 return SWIG_Py_Void();
43841 }
43842
43843 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43844 return SWIG_Python_InitShadowInstance(args);
43845 }
43846
43847 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43848 PyObject *resultobj = 0;
43849 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43850 wxString *arg2 = 0 ;
43851 PyObject *arg3 = (PyObject *) NULL ;
43852 int result;
43853 void *argp1 = 0 ;
43854 int res1 = 0 ;
43855 bool temp2 = false ;
43856 PyObject * obj0 = 0 ;
43857 PyObject * obj1 = 0 ;
43858 PyObject * obj2 = 0 ;
43859 char * kwnames[] = {
43860 (char *) "self",(char *) "item",(char *) "clientData", NULL
43861 };
43862
43863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43865 if (!SWIG_IsOK(res1)) {
43866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43867 }
43868 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43869 {
43870 arg2 = wxString_in_helper(obj1);
43871 if (arg2 == NULL) SWIG_fail;
43872 temp2 = true;
43873 }
43874 if (obj2) {
43875 arg3 = obj2;
43876 }
43877 {
43878 PyThreadState* __tstate = wxPyBeginAllowThreads();
43879 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43880 wxPyEndAllowThreads(__tstate);
43881 if (PyErr_Occurred()) SWIG_fail;
43882 }
43883 resultobj = SWIG_From_int(static_cast< int >(result));
43884 {
43885 if (temp2)
43886 delete arg2;
43887 }
43888 return resultobj;
43889 fail:
43890 {
43891 if (temp2)
43892 delete arg2;
43893 }
43894 return NULL;
43895 }
43896
43897
43898 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43899 PyObject *resultobj = 0;
43900 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43901 wxArrayString *arg2 = 0 ;
43902 void *argp1 = 0 ;
43903 int res1 = 0 ;
43904 bool temp2 = false ;
43905 PyObject * obj0 = 0 ;
43906 PyObject * obj1 = 0 ;
43907 char * kwnames[] = {
43908 (char *) "self",(char *) "strings", NULL
43909 };
43910
43911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43913 if (!SWIG_IsOK(res1)) {
43914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43915 }
43916 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43917 {
43918 if (! PySequence_Check(obj1)) {
43919 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43920 SWIG_fail;
43921 }
43922 arg2 = new wxArrayString;
43923 temp2 = true;
43924 int i, len=PySequence_Length(obj1);
43925 for (i=0; i<len; i++) {
43926 PyObject* item = PySequence_GetItem(obj1, i);
43927 wxString* s = wxString_in_helper(item);
43928 if (PyErr_Occurred()) SWIG_fail;
43929 arg2->Add(*s);
43930 delete s;
43931 Py_DECREF(item);
43932 }
43933 }
43934 {
43935 PyThreadState* __tstate = wxPyBeginAllowThreads();
43936 (arg1)->Append((wxArrayString const &)*arg2);
43937 wxPyEndAllowThreads(__tstate);
43938 if (PyErr_Occurred()) SWIG_fail;
43939 }
43940 resultobj = SWIG_Py_Void();
43941 {
43942 if (temp2) delete arg2;
43943 }
43944 return resultobj;
43945 fail:
43946 {
43947 if (temp2) delete arg2;
43948 }
43949 return NULL;
43950 }
43951
43952
43953 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43954 PyObject *resultobj = 0;
43955 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43956 wxString *arg2 = 0 ;
43957 unsigned int arg3 ;
43958 PyObject *arg4 = (PyObject *) NULL ;
43959 int result;
43960 void *argp1 = 0 ;
43961 int res1 = 0 ;
43962 bool temp2 = false ;
43963 unsigned int val3 ;
43964 int ecode3 = 0 ;
43965 PyObject * obj0 = 0 ;
43966 PyObject * obj1 = 0 ;
43967 PyObject * obj2 = 0 ;
43968 PyObject * obj3 = 0 ;
43969 char * kwnames[] = {
43970 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43971 };
43972
43973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43975 if (!SWIG_IsOK(res1)) {
43976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43977 }
43978 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43979 {
43980 arg2 = wxString_in_helper(obj1);
43981 if (arg2 == NULL) SWIG_fail;
43982 temp2 = true;
43983 }
43984 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
43985 if (!SWIG_IsOK(ecode3)) {
43986 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
43987 }
43988 arg3 = static_cast< unsigned int >(val3);
43989 if (obj3) {
43990 arg4 = obj3;
43991 }
43992 {
43993 PyThreadState* __tstate = wxPyBeginAllowThreads();
43994 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43995 wxPyEndAllowThreads(__tstate);
43996 if (PyErr_Occurred()) SWIG_fail;
43997 }
43998 resultobj = SWIG_From_int(static_cast< int >(result));
43999 {
44000 if (temp2)
44001 delete arg2;
44002 }
44003 return resultobj;
44004 fail:
44005 {
44006 if (temp2)
44007 delete arg2;
44008 }
44009 return NULL;
44010 }
44011
44012
44013 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44014 PyObject *resultobj = 0;
44015 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44016 void *argp1 = 0 ;
44017 int res1 = 0 ;
44018 PyObject *swig_obj[1] ;
44019
44020 if (!args) SWIG_fail;
44021 swig_obj[0] = args;
44022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44023 if (!SWIG_IsOK(res1)) {
44024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44025 }
44026 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44027 {
44028 PyThreadState* __tstate = wxPyBeginAllowThreads();
44029 (arg1)->Clear();
44030 wxPyEndAllowThreads(__tstate);
44031 if (PyErr_Occurred()) SWIG_fail;
44032 }
44033 resultobj = SWIG_Py_Void();
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44041 PyObject *resultobj = 0;
44042 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44043 unsigned int arg2 ;
44044 void *argp1 = 0 ;
44045 int res1 = 0 ;
44046 unsigned int val2 ;
44047 int ecode2 = 0 ;
44048 PyObject * obj0 = 0 ;
44049 PyObject * obj1 = 0 ;
44050 char * kwnames[] = {
44051 (char *) "self",(char *) "n", NULL
44052 };
44053
44054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44056 if (!SWIG_IsOK(res1)) {
44057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44058 }
44059 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44060 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44061 if (!SWIG_IsOK(ecode2)) {
44062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44063 }
44064 arg2 = static_cast< unsigned int >(val2);
44065 {
44066 PyThreadState* __tstate = wxPyBeginAllowThreads();
44067 (arg1)->Delete(arg2);
44068 wxPyEndAllowThreads(__tstate);
44069 if (PyErr_Occurred()) SWIG_fail;
44070 }
44071 resultobj = SWIG_Py_Void();
44072 return resultobj;
44073 fail:
44074 return NULL;
44075 }
44076
44077
44078 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44079 PyObject *resultobj = 0;
44080 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44081 unsigned int arg2 ;
44082 PyObject *result = 0 ;
44083 void *argp1 = 0 ;
44084 int res1 = 0 ;
44085 unsigned int val2 ;
44086 int ecode2 = 0 ;
44087 PyObject * obj0 = 0 ;
44088 PyObject * obj1 = 0 ;
44089 char * kwnames[] = {
44090 (char *) "self",(char *) "n", NULL
44091 };
44092
44093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44095 if (!SWIG_IsOK(res1)) {
44096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44097 }
44098 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44099 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44100 if (!SWIG_IsOK(ecode2)) {
44101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44102 }
44103 arg2 = static_cast< unsigned int >(val2);
44104 {
44105 PyThreadState* __tstate = wxPyBeginAllowThreads();
44106 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44107 wxPyEndAllowThreads(__tstate);
44108 if (PyErr_Occurred()) SWIG_fail;
44109 }
44110 resultobj = result;
44111 return resultobj;
44112 fail:
44113 return NULL;
44114 }
44115
44116
44117 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44118 PyObject *resultobj = 0;
44119 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44120 unsigned int arg2 ;
44121 PyObject *arg3 = (PyObject *) 0 ;
44122 void *argp1 = 0 ;
44123 int res1 = 0 ;
44124 unsigned int val2 ;
44125 int ecode2 = 0 ;
44126 PyObject * obj0 = 0 ;
44127 PyObject * obj1 = 0 ;
44128 PyObject * obj2 = 0 ;
44129 char * kwnames[] = {
44130 (char *) "self",(char *) "n",(char *) "clientData", NULL
44131 };
44132
44133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44135 if (!SWIG_IsOK(res1)) {
44136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44137 }
44138 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44139 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44140 if (!SWIG_IsOK(ecode2)) {
44141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44142 }
44143 arg2 = static_cast< unsigned int >(val2);
44144 arg3 = obj2;
44145 {
44146 PyThreadState* __tstate = wxPyBeginAllowThreads();
44147 wxItemContainer_SetClientData(arg1,arg2,arg3);
44148 wxPyEndAllowThreads(__tstate);
44149 if (PyErr_Occurred()) SWIG_fail;
44150 }
44151 resultobj = SWIG_Py_Void();
44152 return resultobj;
44153 fail:
44154 return NULL;
44155 }
44156
44157
44158 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44159 PyObject *resultobj = 0;
44160 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44161 unsigned int result;
44162 void *argp1 = 0 ;
44163 int res1 = 0 ;
44164 PyObject *swig_obj[1] ;
44165
44166 if (!args) SWIG_fail;
44167 swig_obj[0] = args;
44168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44169 if (!SWIG_IsOK(res1)) {
44170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44171 }
44172 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44173 {
44174 PyThreadState* __tstate = wxPyBeginAllowThreads();
44175 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44176 wxPyEndAllowThreads(__tstate);
44177 if (PyErr_Occurred()) SWIG_fail;
44178 }
44179 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44180 return resultobj;
44181 fail:
44182 return NULL;
44183 }
44184
44185
44186 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44187 PyObject *resultobj = 0;
44188 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44189 bool result;
44190 void *argp1 = 0 ;
44191 int res1 = 0 ;
44192 PyObject *swig_obj[1] ;
44193
44194 if (!args) SWIG_fail;
44195 swig_obj[0] = args;
44196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44197 if (!SWIG_IsOK(res1)) {
44198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44199 }
44200 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44201 {
44202 PyThreadState* __tstate = wxPyBeginAllowThreads();
44203 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44204 wxPyEndAllowThreads(__tstate);
44205 if (PyErr_Occurred()) SWIG_fail;
44206 }
44207 {
44208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44209 }
44210 return resultobj;
44211 fail:
44212 return NULL;
44213 }
44214
44215
44216 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44217 PyObject *resultobj = 0;
44218 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44219 unsigned int arg2 ;
44220 wxString result;
44221 void *argp1 = 0 ;
44222 int res1 = 0 ;
44223 unsigned int val2 ;
44224 int ecode2 = 0 ;
44225 PyObject * obj0 = 0 ;
44226 PyObject * obj1 = 0 ;
44227 char * kwnames[] = {
44228 (char *) "self",(char *) "n", NULL
44229 };
44230
44231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44233 if (!SWIG_IsOK(res1)) {
44234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44235 }
44236 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44237 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44238 if (!SWIG_IsOK(ecode2)) {
44239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44240 }
44241 arg2 = static_cast< unsigned int >(val2);
44242 {
44243 PyThreadState* __tstate = wxPyBeginAllowThreads();
44244 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44245 wxPyEndAllowThreads(__tstate);
44246 if (PyErr_Occurred()) SWIG_fail;
44247 }
44248 {
44249 #if wxUSE_UNICODE
44250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44251 #else
44252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44253 #endif
44254 }
44255 return resultobj;
44256 fail:
44257 return NULL;
44258 }
44259
44260
44261 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44262 PyObject *resultobj = 0;
44263 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44264 wxArrayString result;
44265 void *argp1 = 0 ;
44266 int res1 = 0 ;
44267 PyObject *swig_obj[1] ;
44268
44269 if (!args) SWIG_fail;
44270 swig_obj[0] = args;
44271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44272 if (!SWIG_IsOK(res1)) {
44273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44274 }
44275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44276 {
44277 PyThreadState* __tstate = wxPyBeginAllowThreads();
44278 result = ((wxItemContainer const *)arg1)->GetStrings();
44279 wxPyEndAllowThreads(__tstate);
44280 if (PyErr_Occurred()) SWIG_fail;
44281 }
44282 {
44283 resultobj = wxArrayString2PyList_helper(result);
44284 }
44285 return resultobj;
44286 fail:
44287 return NULL;
44288 }
44289
44290
44291 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44292 PyObject *resultobj = 0;
44293 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44294 unsigned int arg2 ;
44295 wxString *arg3 = 0 ;
44296 void *argp1 = 0 ;
44297 int res1 = 0 ;
44298 unsigned int val2 ;
44299 int ecode2 = 0 ;
44300 bool temp3 = false ;
44301 PyObject * obj0 = 0 ;
44302 PyObject * obj1 = 0 ;
44303 PyObject * obj2 = 0 ;
44304 char * kwnames[] = {
44305 (char *) "self",(char *) "n",(char *) "s", NULL
44306 };
44307
44308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44310 if (!SWIG_IsOK(res1)) {
44311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44312 }
44313 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44314 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44315 if (!SWIG_IsOK(ecode2)) {
44316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44317 }
44318 arg2 = static_cast< unsigned int >(val2);
44319 {
44320 arg3 = wxString_in_helper(obj2);
44321 if (arg3 == NULL) SWIG_fail;
44322 temp3 = true;
44323 }
44324 {
44325 PyThreadState* __tstate = wxPyBeginAllowThreads();
44326 (arg1)->SetString(arg2,(wxString const &)*arg3);
44327 wxPyEndAllowThreads(__tstate);
44328 if (PyErr_Occurred()) SWIG_fail;
44329 }
44330 resultobj = SWIG_Py_Void();
44331 {
44332 if (temp3)
44333 delete arg3;
44334 }
44335 return resultobj;
44336 fail:
44337 {
44338 if (temp3)
44339 delete arg3;
44340 }
44341 return NULL;
44342 }
44343
44344
44345 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44346 PyObject *resultobj = 0;
44347 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44348 wxString *arg2 = 0 ;
44349 int result;
44350 void *argp1 = 0 ;
44351 int res1 = 0 ;
44352 bool temp2 = false ;
44353 PyObject * obj0 = 0 ;
44354 PyObject * obj1 = 0 ;
44355 char * kwnames[] = {
44356 (char *) "self",(char *) "s", NULL
44357 };
44358
44359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44361 if (!SWIG_IsOK(res1)) {
44362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44363 }
44364 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44365 {
44366 arg2 = wxString_in_helper(obj1);
44367 if (arg2 == NULL) SWIG_fail;
44368 temp2 = true;
44369 }
44370 {
44371 PyThreadState* __tstate = wxPyBeginAllowThreads();
44372 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44373 wxPyEndAllowThreads(__tstate);
44374 if (PyErr_Occurred()) SWIG_fail;
44375 }
44376 resultobj = SWIG_From_int(static_cast< int >(result));
44377 {
44378 if (temp2)
44379 delete arg2;
44380 }
44381 return resultobj;
44382 fail:
44383 {
44384 if (temp2)
44385 delete arg2;
44386 }
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44392 PyObject *resultobj = 0;
44393 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44394 int arg2 ;
44395 void *argp1 = 0 ;
44396 int res1 = 0 ;
44397 int val2 ;
44398 int ecode2 = 0 ;
44399 PyObject * obj0 = 0 ;
44400 PyObject * obj1 = 0 ;
44401 char * kwnames[] = {
44402 (char *) "self",(char *) "n", NULL
44403 };
44404
44405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44407 if (!SWIG_IsOK(res1)) {
44408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44409 }
44410 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44411 ecode2 = SWIG_AsVal_int(obj1, &val2);
44412 if (!SWIG_IsOK(ecode2)) {
44413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44414 }
44415 arg2 = static_cast< int >(val2);
44416 {
44417 PyThreadState* __tstate = wxPyBeginAllowThreads();
44418 (arg1)->SetSelection(arg2);
44419 wxPyEndAllowThreads(__tstate);
44420 if (PyErr_Occurred()) SWIG_fail;
44421 }
44422 resultobj = SWIG_Py_Void();
44423 return resultobj;
44424 fail:
44425 return NULL;
44426 }
44427
44428
44429 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44430 PyObject *resultobj = 0;
44431 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44432 int result;
44433 void *argp1 = 0 ;
44434 int res1 = 0 ;
44435 PyObject *swig_obj[1] ;
44436
44437 if (!args) SWIG_fail;
44438 swig_obj[0] = args;
44439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44440 if (!SWIG_IsOK(res1)) {
44441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44442 }
44443 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44444 {
44445 PyThreadState* __tstate = wxPyBeginAllowThreads();
44446 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44447 wxPyEndAllowThreads(__tstate);
44448 if (PyErr_Occurred()) SWIG_fail;
44449 }
44450 resultobj = SWIG_From_int(static_cast< int >(result));
44451 return resultobj;
44452 fail:
44453 return NULL;
44454 }
44455
44456
44457 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44458 PyObject *resultobj = 0;
44459 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44460 wxString *arg2 = 0 ;
44461 bool result;
44462 void *argp1 = 0 ;
44463 int res1 = 0 ;
44464 bool temp2 = false ;
44465 PyObject * obj0 = 0 ;
44466 PyObject * obj1 = 0 ;
44467 char * kwnames[] = {
44468 (char *) "self",(char *) "s", NULL
44469 };
44470
44471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44473 if (!SWIG_IsOK(res1)) {
44474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44475 }
44476 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44477 {
44478 arg2 = wxString_in_helper(obj1);
44479 if (arg2 == NULL) SWIG_fail;
44480 temp2 = true;
44481 }
44482 {
44483 PyThreadState* __tstate = wxPyBeginAllowThreads();
44484 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44485 wxPyEndAllowThreads(__tstate);
44486 if (PyErr_Occurred()) SWIG_fail;
44487 }
44488 {
44489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44490 }
44491 {
44492 if (temp2)
44493 delete arg2;
44494 }
44495 return resultobj;
44496 fail:
44497 {
44498 if (temp2)
44499 delete arg2;
44500 }
44501 return NULL;
44502 }
44503
44504
44505 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44506 PyObject *resultobj = 0;
44507 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44508 wxString result;
44509 void *argp1 = 0 ;
44510 int res1 = 0 ;
44511 PyObject *swig_obj[1] ;
44512
44513 if (!args) SWIG_fail;
44514 swig_obj[0] = args;
44515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44516 if (!SWIG_IsOK(res1)) {
44517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44518 }
44519 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44520 {
44521 PyThreadState* __tstate = wxPyBeginAllowThreads();
44522 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44523 wxPyEndAllowThreads(__tstate);
44524 if (PyErr_Occurred()) SWIG_fail;
44525 }
44526 {
44527 #if wxUSE_UNICODE
44528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44529 #else
44530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44531 #endif
44532 }
44533 return resultobj;
44534 fail:
44535 return NULL;
44536 }
44537
44538
44539 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44540 PyObject *resultobj = 0;
44541 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44542 int arg2 ;
44543 void *argp1 = 0 ;
44544 int res1 = 0 ;
44545 int val2 ;
44546 int ecode2 = 0 ;
44547 PyObject * obj0 = 0 ;
44548 PyObject * obj1 = 0 ;
44549 char * kwnames[] = {
44550 (char *) "self",(char *) "n", NULL
44551 };
44552
44553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44555 if (!SWIG_IsOK(res1)) {
44556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44557 }
44558 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44559 ecode2 = SWIG_AsVal_int(obj1, &val2);
44560 if (!SWIG_IsOK(ecode2)) {
44561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44562 }
44563 arg2 = static_cast< int >(val2);
44564 {
44565 PyThreadState* __tstate = wxPyBeginAllowThreads();
44566 (arg1)->Select(arg2);
44567 wxPyEndAllowThreads(__tstate);
44568 if (PyErr_Occurred()) SWIG_fail;
44569 }
44570 resultobj = SWIG_Py_Void();
44571 return resultobj;
44572 fail:
44573 return NULL;
44574 }
44575
44576
44577 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44578 PyObject *obj;
44579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44580 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44581 return SWIG_Py_Void();
44582 }
44583
44584 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44585 PyObject *obj;
44586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44587 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44588 return SWIG_Py_Void();
44589 }
44590
44591 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44592 PyObject *resultobj = 0;
44593 wxSizerItem *result = 0 ;
44594
44595 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44596 {
44597 PyThreadState* __tstate = wxPyBeginAllowThreads();
44598 result = (wxSizerItem *)new wxSizerItem();
44599 wxPyEndAllowThreads(__tstate);
44600 if (PyErr_Occurred()) SWIG_fail;
44601 }
44602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44603 return resultobj;
44604 fail:
44605 return NULL;
44606 }
44607
44608
44609 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44610 PyObject *resultobj = 0;
44611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44612 void *argp1 = 0 ;
44613 int res1 = 0 ;
44614 PyObject *swig_obj[1] ;
44615
44616 if (!args) SWIG_fail;
44617 swig_obj[0] = args;
44618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44619 if (!SWIG_IsOK(res1)) {
44620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44621 }
44622 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44623 {
44624 PyThreadState* __tstate = wxPyBeginAllowThreads();
44625 delete arg1;
44626
44627 wxPyEndAllowThreads(__tstate);
44628 if (PyErr_Occurred()) SWIG_fail;
44629 }
44630 resultobj = SWIG_Py_Void();
44631 return resultobj;
44632 fail:
44633 return NULL;
44634 }
44635
44636
44637 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44638 PyObject *resultobj = 0;
44639 wxWindow *arg1 = (wxWindow *) 0 ;
44640 int arg2 ;
44641 int arg3 ;
44642 int arg4 ;
44643 PyObject *arg5 = (PyObject *) NULL ;
44644 wxSizerItem *result = 0 ;
44645 void *argp1 = 0 ;
44646 int res1 = 0 ;
44647 int val2 ;
44648 int ecode2 = 0 ;
44649 int val3 ;
44650 int ecode3 = 0 ;
44651 int val4 ;
44652 int ecode4 = 0 ;
44653 PyObject * obj0 = 0 ;
44654 PyObject * obj1 = 0 ;
44655 PyObject * obj2 = 0 ;
44656 PyObject * obj3 = 0 ;
44657 PyObject * obj4 = 0 ;
44658 char * kwnames[] = {
44659 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44660 };
44661
44662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44664 if (!SWIG_IsOK(res1)) {
44665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44666 }
44667 arg1 = reinterpret_cast< wxWindow * >(argp1);
44668 ecode2 = SWIG_AsVal_int(obj1, &val2);
44669 if (!SWIG_IsOK(ecode2)) {
44670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44671 }
44672 arg2 = static_cast< int >(val2);
44673 ecode3 = SWIG_AsVal_int(obj2, &val3);
44674 if (!SWIG_IsOK(ecode3)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44676 }
44677 arg3 = static_cast< int >(val3);
44678 ecode4 = SWIG_AsVal_int(obj3, &val4);
44679 if (!SWIG_IsOK(ecode4)) {
44680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44681 }
44682 arg4 = static_cast< int >(val4);
44683 if (obj4) {
44684 arg5 = obj4;
44685 }
44686 {
44687 PyThreadState* __tstate = wxPyBeginAllowThreads();
44688 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44689 wxPyEndAllowThreads(__tstate);
44690 if (PyErr_Occurred()) SWIG_fail;
44691 }
44692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44693 return resultobj;
44694 fail:
44695 return NULL;
44696 }
44697
44698
44699 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44700 PyObject *resultobj = 0;
44701 int arg1 ;
44702 int arg2 ;
44703 int arg3 ;
44704 int arg4 ;
44705 int arg5 ;
44706 PyObject *arg6 = (PyObject *) NULL ;
44707 wxSizerItem *result = 0 ;
44708 int val1 ;
44709 int ecode1 = 0 ;
44710 int val2 ;
44711 int ecode2 = 0 ;
44712 int val3 ;
44713 int ecode3 = 0 ;
44714 int val4 ;
44715 int ecode4 = 0 ;
44716 int val5 ;
44717 int ecode5 = 0 ;
44718 PyObject * obj0 = 0 ;
44719 PyObject * obj1 = 0 ;
44720 PyObject * obj2 = 0 ;
44721 PyObject * obj3 = 0 ;
44722 PyObject * obj4 = 0 ;
44723 PyObject * obj5 = 0 ;
44724 char * kwnames[] = {
44725 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44726 };
44727
44728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44729 ecode1 = SWIG_AsVal_int(obj0, &val1);
44730 if (!SWIG_IsOK(ecode1)) {
44731 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44732 }
44733 arg1 = static_cast< int >(val1);
44734 ecode2 = SWIG_AsVal_int(obj1, &val2);
44735 if (!SWIG_IsOK(ecode2)) {
44736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44737 }
44738 arg2 = static_cast< int >(val2);
44739 ecode3 = SWIG_AsVal_int(obj2, &val3);
44740 if (!SWIG_IsOK(ecode3)) {
44741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44742 }
44743 arg3 = static_cast< int >(val3);
44744 ecode4 = SWIG_AsVal_int(obj3, &val4);
44745 if (!SWIG_IsOK(ecode4)) {
44746 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44747 }
44748 arg4 = static_cast< int >(val4);
44749 ecode5 = SWIG_AsVal_int(obj4, &val5);
44750 if (!SWIG_IsOK(ecode5)) {
44751 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44752 }
44753 arg5 = static_cast< int >(val5);
44754 if (obj5) {
44755 arg6 = obj5;
44756 }
44757 {
44758 PyThreadState* __tstate = wxPyBeginAllowThreads();
44759 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44760 wxPyEndAllowThreads(__tstate);
44761 if (PyErr_Occurred()) SWIG_fail;
44762 }
44763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44764 return resultobj;
44765 fail:
44766 return NULL;
44767 }
44768
44769
44770 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44771 PyObject *resultobj = 0;
44772 wxSizer *arg1 = (wxSizer *) 0 ;
44773 int arg2 ;
44774 int arg3 ;
44775 int arg4 ;
44776 PyObject *arg5 = (PyObject *) NULL ;
44777 wxSizerItem *result = 0 ;
44778 int res1 = 0 ;
44779 int val2 ;
44780 int ecode2 = 0 ;
44781 int val3 ;
44782 int ecode3 = 0 ;
44783 int val4 ;
44784 int ecode4 = 0 ;
44785 PyObject * obj0 = 0 ;
44786 PyObject * obj1 = 0 ;
44787 PyObject * obj2 = 0 ;
44788 PyObject * obj3 = 0 ;
44789 PyObject * obj4 = 0 ;
44790 char * kwnames[] = {
44791 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44792 };
44793
44794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44795 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44796 if (!SWIG_IsOK(res1)) {
44797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44798 }
44799 ecode2 = SWIG_AsVal_int(obj1, &val2);
44800 if (!SWIG_IsOK(ecode2)) {
44801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44802 }
44803 arg2 = static_cast< int >(val2);
44804 ecode3 = SWIG_AsVal_int(obj2, &val3);
44805 if (!SWIG_IsOK(ecode3)) {
44806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44807 }
44808 arg3 = static_cast< int >(val3);
44809 ecode4 = SWIG_AsVal_int(obj3, &val4);
44810 if (!SWIG_IsOK(ecode4)) {
44811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44812 }
44813 arg4 = static_cast< int >(val4);
44814 if (obj4) {
44815 arg5 = obj4;
44816 }
44817 {
44818 PyThreadState* __tstate = wxPyBeginAllowThreads();
44819 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44820 wxPyEndAllowThreads(__tstate);
44821 if (PyErr_Occurred()) SWIG_fail;
44822 }
44823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44824 return resultobj;
44825 fail:
44826 return NULL;
44827 }
44828
44829
44830 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44831 PyObject *resultobj = 0;
44832 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44833 void *argp1 = 0 ;
44834 int res1 = 0 ;
44835 PyObject *swig_obj[1] ;
44836
44837 if (!args) SWIG_fail;
44838 swig_obj[0] = args;
44839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44840 if (!SWIG_IsOK(res1)) {
44841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44842 }
44843 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44844 {
44845 PyThreadState* __tstate = wxPyBeginAllowThreads();
44846 (arg1)->DeleteWindows();
44847 wxPyEndAllowThreads(__tstate);
44848 if (PyErr_Occurred()) SWIG_fail;
44849 }
44850 resultobj = SWIG_Py_Void();
44851 return resultobj;
44852 fail:
44853 return NULL;
44854 }
44855
44856
44857 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44858 PyObject *resultobj = 0;
44859 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44860 void *argp1 = 0 ;
44861 int res1 = 0 ;
44862 PyObject *swig_obj[1] ;
44863
44864 if (!args) SWIG_fail;
44865 swig_obj[0] = args;
44866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44867 if (!SWIG_IsOK(res1)) {
44868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44869 }
44870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44871 {
44872 PyThreadState* __tstate = wxPyBeginAllowThreads();
44873 (arg1)->DetachSizer();
44874 wxPyEndAllowThreads(__tstate);
44875 if (PyErr_Occurred()) SWIG_fail;
44876 }
44877 resultobj = SWIG_Py_Void();
44878 return resultobj;
44879 fail:
44880 return NULL;
44881 }
44882
44883
44884 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44885 PyObject *resultobj = 0;
44886 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44887 wxSize result;
44888 void *argp1 = 0 ;
44889 int res1 = 0 ;
44890 PyObject *swig_obj[1] ;
44891
44892 if (!args) SWIG_fail;
44893 swig_obj[0] = args;
44894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44895 if (!SWIG_IsOK(res1)) {
44896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44897 }
44898 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44899 {
44900 PyThreadState* __tstate = wxPyBeginAllowThreads();
44901 result = (arg1)->GetSize();
44902 wxPyEndAllowThreads(__tstate);
44903 if (PyErr_Occurred()) SWIG_fail;
44904 }
44905 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44906 return resultobj;
44907 fail:
44908 return NULL;
44909 }
44910
44911
44912 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44913 PyObject *resultobj = 0;
44914 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44915 wxSize result;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 PyObject *swig_obj[1] ;
44919
44920 if (!args) SWIG_fail;
44921 swig_obj[0] = args;
44922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44923 if (!SWIG_IsOK(res1)) {
44924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44925 }
44926 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 result = (arg1)->CalcMin();
44930 wxPyEndAllowThreads(__tstate);
44931 if (PyErr_Occurred()) SWIG_fail;
44932 }
44933 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44934 return resultobj;
44935 fail:
44936 return NULL;
44937 }
44938
44939
44940 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44941 PyObject *resultobj = 0;
44942 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44943 wxPoint *arg2 = 0 ;
44944 wxSize *arg3 = 0 ;
44945 void *argp1 = 0 ;
44946 int res1 = 0 ;
44947 wxPoint temp2 ;
44948 wxSize temp3 ;
44949 PyObject * obj0 = 0 ;
44950 PyObject * obj1 = 0 ;
44951 PyObject * obj2 = 0 ;
44952 char * kwnames[] = {
44953 (char *) "self",(char *) "pos",(char *) "size", NULL
44954 };
44955
44956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44958 if (!SWIG_IsOK(res1)) {
44959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44960 }
44961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44962 {
44963 arg2 = &temp2;
44964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44965 }
44966 {
44967 arg3 = &temp3;
44968 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44969 }
44970 {
44971 PyThreadState* __tstate = wxPyBeginAllowThreads();
44972 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44973 wxPyEndAllowThreads(__tstate);
44974 if (PyErr_Occurred()) SWIG_fail;
44975 }
44976 resultobj = SWIG_Py_Void();
44977 return resultobj;
44978 fail:
44979 return NULL;
44980 }
44981
44982
44983 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44984 PyObject *resultobj = 0;
44985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44986 wxSize result;
44987 void *argp1 = 0 ;
44988 int res1 = 0 ;
44989 PyObject *swig_obj[1] ;
44990
44991 if (!args) SWIG_fail;
44992 swig_obj[0] = args;
44993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44994 if (!SWIG_IsOK(res1)) {
44995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44996 }
44997 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44998 {
44999 PyThreadState* __tstate = wxPyBeginAllowThreads();
45000 result = (arg1)->GetMinSize();
45001 wxPyEndAllowThreads(__tstate);
45002 if (PyErr_Occurred()) SWIG_fail;
45003 }
45004 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45005 return resultobj;
45006 fail:
45007 return NULL;
45008 }
45009
45010
45011 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45012 PyObject *resultobj = 0;
45013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45014 wxSize result;
45015 void *argp1 = 0 ;
45016 int res1 = 0 ;
45017 PyObject *swig_obj[1] ;
45018
45019 if (!args) SWIG_fail;
45020 swig_obj[0] = args;
45021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45022 if (!SWIG_IsOK(res1)) {
45023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45024 }
45025 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45026 {
45027 PyThreadState* __tstate = wxPyBeginAllowThreads();
45028 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45029 wxPyEndAllowThreads(__tstate);
45030 if (PyErr_Occurred()) SWIG_fail;
45031 }
45032 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45033 return resultobj;
45034 fail:
45035 return NULL;
45036 }
45037
45038
45039 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45040 PyObject *resultobj = 0;
45041 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45042 int arg2 ;
45043 int arg3 ;
45044 void *argp1 = 0 ;
45045 int res1 = 0 ;
45046 int val2 ;
45047 int ecode2 = 0 ;
45048 int val3 ;
45049 int ecode3 = 0 ;
45050 PyObject * obj0 = 0 ;
45051 PyObject * obj1 = 0 ;
45052 PyObject * obj2 = 0 ;
45053 char * kwnames[] = {
45054 (char *) "self",(char *) "x",(char *) "y", NULL
45055 };
45056
45057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45059 if (!SWIG_IsOK(res1)) {
45060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45061 }
45062 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45063 ecode2 = SWIG_AsVal_int(obj1, &val2);
45064 if (!SWIG_IsOK(ecode2)) {
45065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45066 }
45067 arg2 = static_cast< int >(val2);
45068 ecode3 = SWIG_AsVal_int(obj2, &val3);
45069 if (!SWIG_IsOK(ecode3)) {
45070 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45071 }
45072 arg3 = static_cast< int >(val3);
45073 {
45074 PyThreadState* __tstate = wxPyBeginAllowThreads();
45075 (arg1)->SetInitSize(arg2,arg3);
45076 wxPyEndAllowThreads(__tstate);
45077 if (PyErr_Occurred()) SWIG_fail;
45078 }
45079 resultobj = SWIG_Py_Void();
45080 return resultobj;
45081 fail:
45082 return NULL;
45083 }
45084
45085
45086 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45087 PyObject *resultobj = 0;
45088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45089 int arg2 ;
45090 int arg3 ;
45091 void *argp1 = 0 ;
45092 int res1 = 0 ;
45093 int val2 ;
45094 int ecode2 = 0 ;
45095 int val3 ;
45096 int ecode3 = 0 ;
45097 PyObject * obj0 = 0 ;
45098 PyObject * obj1 = 0 ;
45099 PyObject * obj2 = 0 ;
45100 char * kwnames[] = {
45101 (char *) "self",(char *) "width",(char *) "height", NULL
45102 };
45103
45104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45106 if (!SWIG_IsOK(res1)) {
45107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45108 }
45109 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45110 ecode2 = SWIG_AsVal_int(obj1, &val2);
45111 if (!SWIG_IsOK(ecode2)) {
45112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45113 }
45114 arg2 = static_cast< int >(val2);
45115 ecode3 = SWIG_AsVal_int(obj2, &val3);
45116 if (!SWIG_IsOK(ecode3)) {
45117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45118 }
45119 arg3 = static_cast< int >(val3);
45120 {
45121 PyThreadState* __tstate = wxPyBeginAllowThreads();
45122 (arg1)->SetRatio(arg2,arg3);
45123 wxPyEndAllowThreads(__tstate);
45124 if (PyErr_Occurred()) SWIG_fail;
45125 }
45126 resultobj = SWIG_Py_Void();
45127 return resultobj;
45128 fail:
45129 return NULL;
45130 }
45131
45132
45133 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45134 PyObject *resultobj = 0;
45135 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45136 wxSize *arg2 = 0 ;
45137 void *argp1 = 0 ;
45138 int res1 = 0 ;
45139 wxSize temp2 ;
45140 PyObject * obj0 = 0 ;
45141 PyObject * obj1 = 0 ;
45142 char * kwnames[] = {
45143 (char *) "self",(char *) "size", NULL
45144 };
45145
45146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45148 if (!SWIG_IsOK(res1)) {
45149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45150 }
45151 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45152 {
45153 arg2 = &temp2;
45154 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45155 }
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 (arg1)->SetRatio((wxSize const &)*arg2);
45159 wxPyEndAllowThreads(__tstate);
45160 if (PyErr_Occurred()) SWIG_fail;
45161 }
45162 resultobj = SWIG_Py_Void();
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45170 PyObject *resultobj = 0;
45171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45172 float arg2 ;
45173 void *argp1 = 0 ;
45174 int res1 = 0 ;
45175 float val2 ;
45176 int ecode2 = 0 ;
45177 PyObject * obj0 = 0 ;
45178 PyObject * obj1 = 0 ;
45179 char * kwnames[] = {
45180 (char *) "self",(char *) "ratio", NULL
45181 };
45182
45183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45185 if (!SWIG_IsOK(res1)) {
45186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45187 }
45188 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45189 ecode2 = SWIG_AsVal_float(obj1, &val2);
45190 if (!SWIG_IsOK(ecode2)) {
45191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45192 }
45193 arg2 = static_cast< float >(val2);
45194 {
45195 PyThreadState* __tstate = wxPyBeginAllowThreads();
45196 (arg1)->SetRatio(arg2);
45197 wxPyEndAllowThreads(__tstate);
45198 if (PyErr_Occurred()) SWIG_fail;
45199 }
45200 resultobj = SWIG_Py_Void();
45201 return resultobj;
45202 fail:
45203 return NULL;
45204 }
45205
45206
45207 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45208 PyObject *resultobj = 0;
45209 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45210 float result;
45211 void *argp1 = 0 ;
45212 int res1 = 0 ;
45213 PyObject *swig_obj[1] ;
45214
45215 if (!args) SWIG_fail;
45216 swig_obj[0] = args;
45217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45218 if (!SWIG_IsOK(res1)) {
45219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45220 }
45221 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45222 {
45223 PyThreadState* __tstate = wxPyBeginAllowThreads();
45224 result = (float)(arg1)->GetRatio();
45225 wxPyEndAllowThreads(__tstate);
45226 if (PyErr_Occurred()) SWIG_fail;
45227 }
45228 resultobj = SWIG_From_float(static_cast< float >(result));
45229 return resultobj;
45230 fail:
45231 return NULL;
45232 }
45233
45234
45235 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45236 PyObject *resultobj = 0;
45237 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45238 wxRect result;
45239 void *argp1 = 0 ;
45240 int res1 = 0 ;
45241 PyObject *swig_obj[1] ;
45242
45243 if (!args) SWIG_fail;
45244 swig_obj[0] = args;
45245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45246 if (!SWIG_IsOK(res1)) {
45247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45248 }
45249 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45250 {
45251 PyThreadState* __tstate = wxPyBeginAllowThreads();
45252 result = (arg1)->GetRect();
45253 wxPyEndAllowThreads(__tstate);
45254 if (PyErr_Occurred()) SWIG_fail;
45255 }
45256 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45257 return resultobj;
45258 fail:
45259 return NULL;
45260 }
45261
45262
45263 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45264 PyObject *resultobj = 0;
45265 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45266 bool result;
45267 void *argp1 = 0 ;
45268 int res1 = 0 ;
45269 PyObject *swig_obj[1] ;
45270
45271 if (!args) SWIG_fail;
45272 swig_obj[0] = args;
45273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45274 if (!SWIG_IsOK(res1)) {
45275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45276 }
45277 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45278 {
45279 PyThreadState* __tstate = wxPyBeginAllowThreads();
45280 result = (bool)(arg1)->IsWindow();
45281 wxPyEndAllowThreads(__tstate);
45282 if (PyErr_Occurred()) SWIG_fail;
45283 }
45284 {
45285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45286 }
45287 return resultobj;
45288 fail:
45289 return NULL;
45290 }
45291
45292
45293 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45294 PyObject *resultobj = 0;
45295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45296 bool result;
45297 void *argp1 = 0 ;
45298 int res1 = 0 ;
45299 PyObject *swig_obj[1] ;
45300
45301 if (!args) SWIG_fail;
45302 swig_obj[0] = args;
45303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45304 if (!SWIG_IsOK(res1)) {
45305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45306 }
45307 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45308 {
45309 PyThreadState* __tstate = wxPyBeginAllowThreads();
45310 result = (bool)(arg1)->IsSizer();
45311 wxPyEndAllowThreads(__tstate);
45312 if (PyErr_Occurred()) SWIG_fail;
45313 }
45314 {
45315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45316 }
45317 return resultobj;
45318 fail:
45319 return NULL;
45320 }
45321
45322
45323 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45324 PyObject *resultobj = 0;
45325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45326 bool result;
45327 void *argp1 = 0 ;
45328 int res1 = 0 ;
45329 PyObject *swig_obj[1] ;
45330
45331 if (!args) SWIG_fail;
45332 swig_obj[0] = args;
45333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45334 if (!SWIG_IsOK(res1)) {
45335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45336 }
45337 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45338 {
45339 PyThreadState* __tstate = wxPyBeginAllowThreads();
45340 result = (bool)(arg1)->IsSpacer();
45341 wxPyEndAllowThreads(__tstate);
45342 if (PyErr_Occurred()) SWIG_fail;
45343 }
45344 {
45345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45346 }
45347 return resultobj;
45348 fail:
45349 return NULL;
45350 }
45351
45352
45353 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45354 PyObject *resultobj = 0;
45355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45356 int arg2 ;
45357 void *argp1 = 0 ;
45358 int res1 = 0 ;
45359 int val2 ;
45360 int ecode2 = 0 ;
45361 PyObject * obj0 = 0 ;
45362 PyObject * obj1 = 0 ;
45363 char * kwnames[] = {
45364 (char *) "self",(char *) "proportion", NULL
45365 };
45366
45367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45369 if (!SWIG_IsOK(res1)) {
45370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45371 }
45372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45373 ecode2 = SWIG_AsVal_int(obj1, &val2);
45374 if (!SWIG_IsOK(ecode2)) {
45375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45376 }
45377 arg2 = static_cast< int >(val2);
45378 {
45379 PyThreadState* __tstate = wxPyBeginAllowThreads();
45380 (arg1)->SetProportion(arg2);
45381 wxPyEndAllowThreads(__tstate);
45382 if (PyErr_Occurred()) SWIG_fail;
45383 }
45384 resultobj = SWIG_Py_Void();
45385 return resultobj;
45386 fail:
45387 return NULL;
45388 }
45389
45390
45391 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45392 PyObject *resultobj = 0;
45393 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45394 int result;
45395 void *argp1 = 0 ;
45396 int res1 = 0 ;
45397 PyObject *swig_obj[1] ;
45398
45399 if (!args) SWIG_fail;
45400 swig_obj[0] = args;
45401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45402 if (!SWIG_IsOK(res1)) {
45403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45404 }
45405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 result = (int)(arg1)->GetProportion();
45409 wxPyEndAllowThreads(__tstate);
45410 if (PyErr_Occurred()) SWIG_fail;
45411 }
45412 resultobj = SWIG_From_int(static_cast< int >(result));
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45420 PyObject *resultobj = 0;
45421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45422 int arg2 ;
45423 void *argp1 = 0 ;
45424 int res1 = 0 ;
45425 int val2 ;
45426 int ecode2 = 0 ;
45427 PyObject * obj0 = 0 ;
45428 PyObject * obj1 = 0 ;
45429 char * kwnames[] = {
45430 (char *) "self",(char *) "flag", NULL
45431 };
45432
45433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45435 if (!SWIG_IsOK(res1)) {
45436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45437 }
45438 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45439 ecode2 = SWIG_AsVal_int(obj1, &val2);
45440 if (!SWIG_IsOK(ecode2)) {
45441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45442 }
45443 arg2 = static_cast< int >(val2);
45444 {
45445 PyThreadState* __tstate = wxPyBeginAllowThreads();
45446 (arg1)->SetFlag(arg2);
45447 wxPyEndAllowThreads(__tstate);
45448 if (PyErr_Occurred()) SWIG_fail;
45449 }
45450 resultobj = SWIG_Py_Void();
45451 return resultobj;
45452 fail:
45453 return NULL;
45454 }
45455
45456
45457 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45458 PyObject *resultobj = 0;
45459 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45460 int result;
45461 void *argp1 = 0 ;
45462 int res1 = 0 ;
45463 PyObject *swig_obj[1] ;
45464
45465 if (!args) SWIG_fail;
45466 swig_obj[0] = args;
45467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45468 if (!SWIG_IsOK(res1)) {
45469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45470 }
45471 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45472 {
45473 PyThreadState* __tstate = wxPyBeginAllowThreads();
45474 result = (int)(arg1)->GetFlag();
45475 wxPyEndAllowThreads(__tstate);
45476 if (PyErr_Occurred()) SWIG_fail;
45477 }
45478 resultobj = SWIG_From_int(static_cast< int >(result));
45479 return resultobj;
45480 fail:
45481 return NULL;
45482 }
45483
45484
45485 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45486 PyObject *resultobj = 0;
45487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45488 int arg2 ;
45489 void *argp1 = 0 ;
45490 int res1 = 0 ;
45491 int val2 ;
45492 int ecode2 = 0 ;
45493 PyObject * obj0 = 0 ;
45494 PyObject * obj1 = 0 ;
45495 char * kwnames[] = {
45496 (char *) "self",(char *) "border", NULL
45497 };
45498
45499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45501 if (!SWIG_IsOK(res1)) {
45502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45503 }
45504 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45505 ecode2 = SWIG_AsVal_int(obj1, &val2);
45506 if (!SWIG_IsOK(ecode2)) {
45507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45508 }
45509 arg2 = static_cast< int >(val2);
45510 {
45511 PyThreadState* __tstate = wxPyBeginAllowThreads();
45512 (arg1)->SetBorder(arg2);
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 resultobj = SWIG_Py_Void();
45517 return resultobj;
45518 fail:
45519 return NULL;
45520 }
45521
45522
45523 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45524 PyObject *resultobj = 0;
45525 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45526 int result;
45527 void *argp1 = 0 ;
45528 int res1 = 0 ;
45529 PyObject *swig_obj[1] ;
45530
45531 if (!args) SWIG_fail;
45532 swig_obj[0] = args;
45533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45534 if (!SWIG_IsOK(res1)) {
45535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45536 }
45537 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45538 {
45539 PyThreadState* __tstate = wxPyBeginAllowThreads();
45540 result = (int)(arg1)->GetBorder();
45541 wxPyEndAllowThreads(__tstate);
45542 if (PyErr_Occurred()) SWIG_fail;
45543 }
45544 resultobj = SWIG_From_int(static_cast< int >(result));
45545 return resultobj;
45546 fail:
45547 return NULL;
45548 }
45549
45550
45551 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45552 PyObject *resultobj = 0;
45553 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45554 wxWindow *result = 0 ;
45555 void *argp1 = 0 ;
45556 int res1 = 0 ;
45557 PyObject *swig_obj[1] ;
45558
45559 if (!args) SWIG_fail;
45560 swig_obj[0] = args;
45561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45562 if (!SWIG_IsOK(res1)) {
45563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45564 }
45565 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45566 {
45567 PyThreadState* __tstate = wxPyBeginAllowThreads();
45568 result = (wxWindow *)(arg1)->GetWindow();
45569 wxPyEndAllowThreads(__tstate);
45570 if (PyErr_Occurred()) SWIG_fail;
45571 }
45572 {
45573 resultobj = wxPyMake_wxObject(result, 0);
45574 }
45575 return resultobj;
45576 fail:
45577 return NULL;
45578 }
45579
45580
45581 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45582 PyObject *resultobj = 0;
45583 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45584 wxWindow *arg2 = (wxWindow *) 0 ;
45585 void *argp1 = 0 ;
45586 int res1 = 0 ;
45587 void *argp2 = 0 ;
45588 int res2 = 0 ;
45589 PyObject * obj0 = 0 ;
45590 PyObject * obj1 = 0 ;
45591 char * kwnames[] = {
45592 (char *) "self",(char *) "window", NULL
45593 };
45594
45595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45597 if (!SWIG_IsOK(res1)) {
45598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45599 }
45600 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45601 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45602 if (!SWIG_IsOK(res2)) {
45603 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45604 }
45605 arg2 = reinterpret_cast< wxWindow * >(argp2);
45606 {
45607 PyThreadState* __tstate = wxPyBeginAllowThreads();
45608 (arg1)->SetWindow(arg2);
45609 wxPyEndAllowThreads(__tstate);
45610 if (PyErr_Occurred()) SWIG_fail;
45611 }
45612 resultobj = SWIG_Py_Void();
45613 return resultobj;
45614 fail:
45615 return NULL;
45616 }
45617
45618
45619 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45620 PyObject *resultobj = 0;
45621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45622 wxSizer *result = 0 ;
45623 void *argp1 = 0 ;
45624 int res1 = 0 ;
45625 PyObject *swig_obj[1] ;
45626
45627 if (!args) SWIG_fail;
45628 swig_obj[0] = args;
45629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45630 if (!SWIG_IsOK(res1)) {
45631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45632 }
45633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45634 {
45635 PyThreadState* __tstate = wxPyBeginAllowThreads();
45636 result = (wxSizer *)(arg1)->GetSizer();
45637 wxPyEndAllowThreads(__tstate);
45638 if (PyErr_Occurred()) SWIG_fail;
45639 }
45640 {
45641 resultobj = wxPyMake_wxObject(result, (bool)0);
45642 }
45643 return resultobj;
45644 fail:
45645 return NULL;
45646 }
45647
45648
45649 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45650 PyObject *resultobj = 0;
45651 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45652 wxSizer *arg2 = (wxSizer *) 0 ;
45653 void *argp1 = 0 ;
45654 int res1 = 0 ;
45655 int res2 = 0 ;
45656 PyObject * obj0 = 0 ;
45657 PyObject * obj1 = 0 ;
45658 char * kwnames[] = {
45659 (char *) "self",(char *) "sizer", NULL
45660 };
45661
45662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45664 if (!SWIG_IsOK(res1)) {
45665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45666 }
45667 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45668 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45669 if (!SWIG_IsOK(res2)) {
45670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45671 }
45672 {
45673 PyThreadState* __tstate = wxPyBeginAllowThreads();
45674 (arg1)->SetSizer(arg2);
45675 wxPyEndAllowThreads(__tstate);
45676 if (PyErr_Occurred()) SWIG_fail;
45677 }
45678 resultobj = SWIG_Py_Void();
45679 return resultobj;
45680 fail:
45681 return NULL;
45682 }
45683
45684
45685 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45686 PyObject *resultobj = 0;
45687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45688 wxSize *result = 0 ;
45689 void *argp1 = 0 ;
45690 int res1 = 0 ;
45691 PyObject *swig_obj[1] ;
45692
45693 if (!args) SWIG_fail;
45694 swig_obj[0] = args;
45695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45696 if (!SWIG_IsOK(res1)) {
45697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45698 }
45699 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45700 {
45701 PyThreadState* __tstate = wxPyBeginAllowThreads();
45702 {
45703 wxSize const &_result_ref = (arg1)->GetSpacer();
45704 result = (wxSize *) &_result_ref;
45705 }
45706 wxPyEndAllowThreads(__tstate);
45707 if (PyErr_Occurred()) SWIG_fail;
45708 }
45709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45710 return resultobj;
45711 fail:
45712 return NULL;
45713 }
45714
45715
45716 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45717 PyObject *resultobj = 0;
45718 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45719 wxSize *arg2 = 0 ;
45720 void *argp1 = 0 ;
45721 int res1 = 0 ;
45722 wxSize temp2 ;
45723 PyObject * obj0 = 0 ;
45724 PyObject * obj1 = 0 ;
45725 char * kwnames[] = {
45726 (char *) "self",(char *) "size", NULL
45727 };
45728
45729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45731 if (!SWIG_IsOK(res1)) {
45732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45733 }
45734 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45735 {
45736 arg2 = &temp2;
45737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45738 }
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 (arg1)->SetSpacer((wxSize const &)*arg2);
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 resultobj = SWIG_Py_Void();
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45755 bool arg2 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 bool val2 ;
45759 int ecode2 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "show", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45770 }
45771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45772 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45773 if (!SWIG_IsOK(ecode2)) {
45774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45775 }
45776 arg2 = static_cast< bool >(val2);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 (arg1)->Show(arg2);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = SWIG_Py_Void();
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45791 PyObject *resultobj = 0;
45792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45793 bool result;
45794 void *argp1 = 0 ;
45795 int res1 = 0 ;
45796 PyObject *swig_obj[1] ;
45797
45798 if (!args) SWIG_fail;
45799 swig_obj[0] = args;
45800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45801 if (!SWIG_IsOK(res1)) {
45802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45803 }
45804 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45805 {
45806 PyThreadState* __tstate = wxPyBeginAllowThreads();
45807 result = (bool)(arg1)->IsShown();
45808 wxPyEndAllowThreads(__tstate);
45809 if (PyErr_Occurred()) SWIG_fail;
45810 }
45811 {
45812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45813 }
45814 return resultobj;
45815 fail:
45816 return NULL;
45817 }
45818
45819
45820 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45821 PyObject *resultobj = 0;
45822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45823 wxPoint result;
45824 void *argp1 = 0 ;
45825 int res1 = 0 ;
45826 PyObject *swig_obj[1] ;
45827
45828 if (!args) SWIG_fail;
45829 swig_obj[0] = args;
45830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45831 if (!SWIG_IsOK(res1)) {
45832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45833 }
45834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45835 {
45836 PyThreadState* __tstate = wxPyBeginAllowThreads();
45837 result = (arg1)->GetPosition();
45838 wxPyEndAllowThreads(__tstate);
45839 if (PyErr_Occurred()) SWIG_fail;
45840 }
45841 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45842 return resultobj;
45843 fail:
45844 return NULL;
45845 }
45846
45847
45848 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45849 PyObject *resultobj = 0;
45850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45851 PyObject *result = 0 ;
45852 void *argp1 = 0 ;
45853 int res1 = 0 ;
45854 PyObject *swig_obj[1] ;
45855
45856 if (!args) SWIG_fail;
45857 swig_obj[0] = args;
45858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45859 if (!SWIG_IsOK(res1)) {
45860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45861 }
45862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45863 {
45864 PyThreadState* __tstate = wxPyBeginAllowThreads();
45865 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45866 wxPyEndAllowThreads(__tstate);
45867 if (PyErr_Occurred()) SWIG_fail;
45868 }
45869 resultobj = result;
45870 return resultobj;
45871 fail:
45872 return NULL;
45873 }
45874
45875
45876 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45877 PyObject *resultobj = 0;
45878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45879 PyObject *arg2 = (PyObject *) 0 ;
45880 void *argp1 = 0 ;
45881 int res1 = 0 ;
45882 PyObject * obj0 = 0 ;
45883 PyObject * obj1 = 0 ;
45884 char * kwnames[] = {
45885 (char *) "self",(char *) "userData", NULL
45886 };
45887
45888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45890 if (!SWIG_IsOK(res1)) {
45891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45892 }
45893 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45894 arg2 = obj1;
45895 {
45896 PyThreadState* __tstate = wxPyBeginAllowThreads();
45897 wxSizerItem_SetUserData(arg1,arg2);
45898 wxPyEndAllowThreads(__tstate);
45899 if (PyErr_Occurred()) SWIG_fail;
45900 }
45901 resultobj = SWIG_Py_Void();
45902 return resultobj;
45903 fail:
45904 return NULL;
45905 }
45906
45907
45908 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45909 PyObject *obj;
45910 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45911 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45912 return SWIG_Py_Void();
45913 }
45914
45915 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45916 return SWIG_Python_InitShadowInstance(args);
45917 }
45918
45919 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45920 PyObject *resultobj = 0;
45921 wxSizer *arg1 = (wxSizer *) 0 ;
45922 void *argp1 = 0 ;
45923 int res1 = 0 ;
45924 PyObject *swig_obj[1] ;
45925
45926 if (!args) SWIG_fail;
45927 swig_obj[0] = args;
45928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45929 if (!SWIG_IsOK(res1)) {
45930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45931 }
45932 arg1 = reinterpret_cast< wxSizer * >(argp1);
45933 {
45934 PyThreadState* __tstate = wxPyBeginAllowThreads();
45935 delete arg1;
45936
45937 wxPyEndAllowThreads(__tstate);
45938 if (PyErr_Occurred()) SWIG_fail;
45939 }
45940 resultobj = SWIG_Py_Void();
45941 return resultobj;
45942 fail:
45943 return NULL;
45944 }
45945
45946
45947 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45948 PyObject *resultobj = 0;
45949 wxSizer *arg1 = (wxSizer *) 0 ;
45950 PyObject *arg2 = (PyObject *) 0 ;
45951 void *argp1 = 0 ;
45952 int res1 = 0 ;
45953 PyObject * obj0 = 0 ;
45954 PyObject * obj1 = 0 ;
45955 char * kwnames[] = {
45956 (char *) "self",(char *) "_self", NULL
45957 };
45958
45959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45961 if (!SWIG_IsOK(res1)) {
45962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45963 }
45964 arg1 = reinterpret_cast< wxSizer * >(argp1);
45965 arg2 = obj1;
45966 {
45967 PyThreadState* __tstate = wxPyBeginAllowThreads();
45968 wxSizer__setOORInfo(arg1,arg2);
45969 wxPyEndAllowThreads(__tstate);
45970 if (PyErr_Occurred()) SWIG_fail;
45971 }
45972 resultobj = SWIG_Py_Void();
45973 return resultobj;
45974 fail:
45975 return NULL;
45976 }
45977
45978
45979 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45980 PyObject *resultobj = 0;
45981 wxSizer *arg1 = (wxSizer *) 0 ;
45982 PyObject *arg2 = (PyObject *) 0 ;
45983 int arg3 = (int) 0 ;
45984 int arg4 = (int) 0 ;
45985 int arg5 = (int) 0 ;
45986 PyObject *arg6 = (PyObject *) NULL ;
45987 wxSizerItem *result = 0 ;
45988 void *argp1 = 0 ;
45989 int res1 = 0 ;
45990 int val3 ;
45991 int ecode3 = 0 ;
45992 int val4 ;
45993 int ecode4 = 0 ;
45994 int val5 ;
45995 int ecode5 = 0 ;
45996 PyObject * obj0 = 0 ;
45997 PyObject * obj1 = 0 ;
45998 PyObject * obj2 = 0 ;
45999 PyObject * obj3 = 0 ;
46000 PyObject * obj4 = 0 ;
46001 PyObject * obj5 = 0 ;
46002 char * kwnames[] = {
46003 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46004 };
46005
46006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46008 if (!SWIG_IsOK(res1)) {
46009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46010 }
46011 arg1 = reinterpret_cast< wxSizer * >(argp1);
46012 arg2 = obj1;
46013 if (obj2) {
46014 ecode3 = SWIG_AsVal_int(obj2, &val3);
46015 if (!SWIG_IsOK(ecode3)) {
46016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46017 }
46018 arg3 = static_cast< int >(val3);
46019 }
46020 if (obj3) {
46021 ecode4 = SWIG_AsVal_int(obj3, &val4);
46022 if (!SWIG_IsOK(ecode4)) {
46023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46024 }
46025 arg4 = static_cast< int >(val4);
46026 }
46027 if (obj4) {
46028 ecode5 = SWIG_AsVal_int(obj4, &val5);
46029 if (!SWIG_IsOK(ecode5)) {
46030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46031 }
46032 arg5 = static_cast< int >(val5);
46033 }
46034 if (obj5) {
46035 arg6 = obj5;
46036 }
46037 {
46038 PyThreadState* __tstate = wxPyBeginAllowThreads();
46039 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46040 wxPyEndAllowThreads(__tstate);
46041 if (PyErr_Occurred()) SWIG_fail;
46042 }
46043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46044 return resultobj;
46045 fail:
46046 return NULL;
46047 }
46048
46049
46050 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46051 PyObject *resultobj = 0;
46052 wxSizer *arg1 = (wxSizer *) 0 ;
46053 int arg2 ;
46054 PyObject *arg3 = (PyObject *) 0 ;
46055 int arg4 = (int) 0 ;
46056 int arg5 = (int) 0 ;
46057 int arg6 = (int) 0 ;
46058 PyObject *arg7 = (PyObject *) NULL ;
46059 wxSizerItem *result = 0 ;
46060 void *argp1 = 0 ;
46061 int res1 = 0 ;
46062 int val2 ;
46063 int ecode2 = 0 ;
46064 int val4 ;
46065 int ecode4 = 0 ;
46066 int val5 ;
46067 int ecode5 = 0 ;
46068 int val6 ;
46069 int ecode6 = 0 ;
46070 PyObject * obj0 = 0 ;
46071 PyObject * obj1 = 0 ;
46072 PyObject * obj2 = 0 ;
46073 PyObject * obj3 = 0 ;
46074 PyObject * obj4 = 0 ;
46075 PyObject * obj5 = 0 ;
46076 PyObject * obj6 = 0 ;
46077 char * kwnames[] = {
46078 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46079 };
46080
46081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46083 if (!SWIG_IsOK(res1)) {
46084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46085 }
46086 arg1 = reinterpret_cast< wxSizer * >(argp1);
46087 ecode2 = SWIG_AsVal_int(obj1, &val2);
46088 if (!SWIG_IsOK(ecode2)) {
46089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46090 }
46091 arg2 = static_cast< int >(val2);
46092 arg3 = obj2;
46093 if (obj3) {
46094 ecode4 = SWIG_AsVal_int(obj3, &val4);
46095 if (!SWIG_IsOK(ecode4)) {
46096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46097 }
46098 arg4 = static_cast< int >(val4);
46099 }
46100 if (obj4) {
46101 ecode5 = SWIG_AsVal_int(obj4, &val5);
46102 if (!SWIG_IsOK(ecode5)) {
46103 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46104 }
46105 arg5 = static_cast< int >(val5);
46106 }
46107 if (obj5) {
46108 ecode6 = SWIG_AsVal_int(obj5, &val6);
46109 if (!SWIG_IsOK(ecode6)) {
46110 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46111 }
46112 arg6 = static_cast< int >(val6);
46113 }
46114 if (obj6) {
46115 arg7 = obj6;
46116 }
46117 {
46118 PyThreadState* __tstate = wxPyBeginAllowThreads();
46119 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46120 wxPyEndAllowThreads(__tstate);
46121 if (PyErr_Occurred()) SWIG_fail;
46122 }
46123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46124 return resultobj;
46125 fail:
46126 return NULL;
46127 }
46128
46129
46130 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46131 PyObject *resultobj = 0;
46132 wxSizer *arg1 = (wxSizer *) 0 ;
46133 PyObject *arg2 = (PyObject *) 0 ;
46134 int arg3 = (int) 0 ;
46135 int arg4 = (int) 0 ;
46136 int arg5 = (int) 0 ;
46137 PyObject *arg6 = (PyObject *) NULL ;
46138 wxSizerItem *result = 0 ;
46139 void *argp1 = 0 ;
46140 int res1 = 0 ;
46141 int val3 ;
46142 int ecode3 = 0 ;
46143 int val4 ;
46144 int ecode4 = 0 ;
46145 int val5 ;
46146 int ecode5 = 0 ;
46147 PyObject * obj0 = 0 ;
46148 PyObject * obj1 = 0 ;
46149 PyObject * obj2 = 0 ;
46150 PyObject * obj3 = 0 ;
46151 PyObject * obj4 = 0 ;
46152 PyObject * obj5 = 0 ;
46153 char * kwnames[] = {
46154 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46155 };
46156
46157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46159 if (!SWIG_IsOK(res1)) {
46160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46161 }
46162 arg1 = reinterpret_cast< wxSizer * >(argp1);
46163 arg2 = obj1;
46164 if (obj2) {
46165 ecode3 = SWIG_AsVal_int(obj2, &val3);
46166 if (!SWIG_IsOK(ecode3)) {
46167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46168 }
46169 arg3 = static_cast< int >(val3);
46170 }
46171 if (obj3) {
46172 ecode4 = SWIG_AsVal_int(obj3, &val4);
46173 if (!SWIG_IsOK(ecode4)) {
46174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46175 }
46176 arg4 = static_cast< int >(val4);
46177 }
46178 if (obj4) {
46179 ecode5 = SWIG_AsVal_int(obj4, &val5);
46180 if (!SWIG_IsOK(ecode5)) {
46181 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46182 }
46183 arg5 = static_cast< int >(val5);
46184 }
46185 if (obj5) {
46186 arg6 = obj5;
46187 }
46188 {
46189 PyThreadState* __tstate = wxPyBeginAllowThreads();
46190 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46191 wxPyEndAllowThreads(__tstate);
46192 if (PyErr_Occurred()) SWIG_fail;
46193 }
46194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46195 return resultobj;
46196 fail:
46197 return NULL;
46198 }
46199
46200
46201 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46202 PyObject *resultobj = 0;
46203 wxSizer *arg1 = (wxSizer *) 0 ;
46204 PyObject *arg2 = (PyObject *) 0 ;
46205 bool result;
46206 void *argp1 = 0 ;
46207 int res1 = 0 ;
46208 PyObject * obj0 = 0 ;
46209 PyObject * obj1 = 0 ;
46210 char * kwnames[] = {
46211 (char *) "self",(char *) "item", NULL
46212 };
46213
46214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46216 if (!SWIG_IsOK(res1)) {
46217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46218 }
46219 arg1 = reinterpret_cast< wxSizer * >(argp1);
46220 arg2 = obj1;
46221 {
46222 PyThreadState* __tstate = wxPyBeginAllowThreads();
46223 result = (bool)wxSizer_Remove(arg1,arg2);
46224 wxPyEndAllowThreads(__tstate);
46225 if (PyErr_Occurred()) SWIG_fail;
46226 }
46227 {
46228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46229 }
46230 return resultobj;
46231 fail:
46232 return NULL;
46233 }
46234
46235
46236 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46237 PyObject *resultobj = 0;
46238 wxSizer *arg1 = (wxSizer *) 0 ;
46239 PyObject *arg2 = (PyObject *) 0 ;
46240 bool result;
46241 void *argp1 = 0 ;
46242 int res1 = 0 ;
46243 PyObject * obj0 = 0 ;
46244 PyObject * obj1 = 0 ;
46245 char * kwnames[] = {
46246 (char *) "self",(char *) "item", NULL
46247 };
46248
46249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46251 if (!SWIG_IsOK(res1)) {
46252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46253 }
46254 arg1 = reinterpret_cast< wxSizer * >(argp1);
46255 arg2 = obj1;
46256 {
46257 PyThreadState* __tstate = wxPyBeginAllowThreads();
46258 result = (bool)wxSizer_Detach(arg1,arg2);
46259 wxPyEndAllowThreads(__tstate);
46260 if (PyErr_Occurred()) SWIG_fail;
46261 }
46262 {
46263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46264 }
46265 return resultobj;
46266 fail:
46267 return NULL;
46268 }
46269
46270
46271 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46272 PyObject *resultobj = 0;
46273 wxSizer *arg1 = (wxSizer *) 0 ;
46274 PyObject *arg2 = (PyObject *) 0 ;
46275 wxSizerItem *result = 0 ;
46276 void *argp1 = 0 ;
46277 int res1 = 0 ;
46278 PyObject * obj0 = 0 ;
46279 PyObject * obj1 = 0 ;
46280 char * kwnames[] = {
46281 (char *) "self",(char *) "item", NULL
46282 };
46283
46284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46286 if (!SWIG_IsOK(res1)) {
46287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46288 }
46289 arg1 = reinterpret_cast< wxSizer * >(argp1);
46290 arg2 = obj1;
46291 {
46292 PyThreadState* __tstate = wxPyBeginAllowThreads();
46293 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46294 wxPyEndAllowThreads(__tstate);
46295 if (PyErr_Occurred()) SWIG_fail;
46296 }
46297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46298 return resultobj;
46299 fail:
46300 return NULL;
46301 }
46302
46303
46304 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46305 PyObject *resultobj = 0;
46306 wxSizer *arg1 = (wxSizer *) 0 ;
46307 PyObject *arg2 = (PyObject *) 0 ;
46308 wxSize *arg3 = 0 ;
46309 void *argp1 = 0 ;
46310 int res1 = 0 ;
46311 wxSize temp3 ;
46312 PyObject * obj0 = 0 ;
46313 PyObject * obj1 = 0 ;
46314 PyObject * obj2 = 0 ;
46315 char * kwnames[] = {
46316 (char *) "self",(char *) "item",(char *) "size", NULL
46317 };
46318
46319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46321 if (!SWIG_IsOK(res1)) {
46322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46323 }
46324 arg1 = reinterpret_cast< wxSizer * >(argp1);
46325 arg2 = obj1;
46326 {
46327 arg3 = &temp3;
46328 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46329 }
46330 {
46331 PyThreadState* __tstate = wxPyBeginAllowThreads();
46332 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46333 wxPyEndAllowThreads(__tstate);
46334 if (PyErr_Occurred()) SWIG_fail;
46335 }
46336 resultobj = SWIG_Py_Void();
46337 return resultobj;
46338 fail:
46339 return NULL;
46340 }
46341
46342
46343 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46344 PyObject *resultobj = 0;
46345 wxSizer *arg1 = (wxSizer *) 0 ;
46346 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46347 wxSizerItem *result = 0 ;
46348 void *argp1 = 0 ;
46349 int res1 = 0 ;
46350 int res2 = 0 ;
46351 PyObject * obj0 = 0 ;
46352 PyObject * obj1 = 0 ;
46353 char * kwnames[] = {
46354 (char *) "self",(char *) "item", NULL
46355 };
46356
46357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46359 if (!SWIG_IsOK(res1)) {
46360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46361 }
46362 arg1 = reinterpret_cast< wxSizer * >(argp1);
46363 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46364 if (!SWIG_IsOK(res2)) {
46365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46366 }
46367 {
46368 PyThreadState* __tstate = wxPyBeginAllowThreads();
46369 result = (wxSizerItem *)(arg1)->Add(arg2);
46370 wxPyEndAllowThreads(__tstate);
46371 if (PyErr_Occurred()) SWIG_fail;
46372 }
46373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46374 return resultobj;
46375 fail:
46376 return NULL;
46377 }
46378
46379
46380 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46381 PyObject *resultobj = 0;
46382 wxSizer *arg1 = (wxSizer *) 0 ;
46383 size_t arg2 ;
46384 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46385 wxSizerItem *result = 0 ;
46386 void *argp1 = 0 ;
46387 int res1 = 0 ;
46388 size_t val2 ;
46389 int ecode2 = 0 ;
46390 int res3 = 0 ;
46391 PyObject * obj0 = 0 ;
46392 PyObject * obj1 = 0 ;
46393 PyObject * obj2 = 0 ;
46394 char * kwnames[] = {
46395 (char *) "self",(char *) "index",(char *) "item", NULL
46396 };
46397
46398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46400 if (!SWIG_IsOK(res1)) {
46401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46402 }
46403 arg1 = reinterpret_cast< wxSizer * >(argp1);
46404 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46405 if (!SWIG_IsOK(ecode2)) {
46406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46407 }
46408 arg2 = static_cast< size_t >(val2);
46409 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46410 if (!SWIG_IsOK(res3)) {
46411 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46412 }
46413 {
46414 PyThreadState* __tstate = wxPyBeginAllowThreads();
46415 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46416 wxPyEndAllowThreads(__tstate);
46417 if (PyErr_Occurred()) SWIG_fail;
46418 }
46419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46420 return resultobj;
46421 fail:
46422 return NULL;
46423 }
46424
46425
46426 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46427 PyObject *resultobj = 0;
46428 wxSizer *arg1 = (wxSizer *) 0 ;
46429 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46430 wxSizerItem *result = 0 ;
46431 void *argp1 = 0 ;
46432 int res1 = 0 ;
46433 int res2 = 0 ;
46434 PyObject * obj0 = 0 ;
46435 PyObject * obj1 = 0 ;
46436 char * kwnames[] = {
46437 (char *) "self",(char *) "item", NULL
46438 };
46439
46440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46442 if (!SWIG_IsOK(res1)) {
46443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46444 }
46445 arg1 = reinterpret_cast< wxSizer * >(argp1);
46446 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46447 if (!SWIG_IsOK(res2)) {
46448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46449 }
46450 {
46451 PyThreadState* __tstate = wxPyBeginAllowThreads();
46452 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46453 wxPyEndAllowThreads(__tstate);
46454 if (PyErr_Occurred()) SWIG_fail;
46455 }
46456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46457 return resultobj;
46458 fail:
46459 return NULL;
46460 }
46461
46462
46463 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46464 PyObject *resultobj = 0;
46465 wxSizer *arg1 = (wxSizer *) 0 ;
46466 int arg2 ;
46467 int arg3 ;
46468 int arg4 ;
46469 int arg5 ;
46470 void *argp1 = 0 ;
46471 int res1 = 0 ;
46472 int val2 ;
46473 int ecode2 = 0 ;
46474 int val3 ;
46475 int ecode3 = 0 ;
46476 int val4 ;
46477 int ecode4 = 0 ;
46478 int val5 ;
46479 int ecode5 = 0 ;
46480 PyObject * obj0 = 0 ;
46481 PyObject * obj1 = 0 ;
46482 PyObject * obj2 = 0 ;
46483 PyObject * obj3 = 0 ;
46484 PyObject * obj4 = 0 ;
46485 char * kwnames[] = {
46486 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46487 };
46488
46489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46491 if (!SWIG_IsOK(res1)) {
46492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46493 }
46494 arg1 = reinterpret_cast< wxSizer * >(argp1);
46495 ecode2 = SWIG_AsVal_int(obj1, &val2);
46496 if (!SWIG_IsOK(ecode2)) {
46497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46498 }
46499 arg2 = static_cast< int >(val2);
46500 ecode3 = SWIG_AsVal_int(obj2, &val3);
46501 if (!SWIG_IsOK(ecode3)) {
46502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46503 }
46504 arg3 = static_cast< int >(val3);
46505 ecode4 = SWIG_AsVal_int(obj3, &val4);
46506 if (!SWIG_IsOK(ecode4)) {
46507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46508 }
46509 arg4 = static_cast< int >(val4);
46510 ecode5 = SWIG_AsVal_int(obj4, &val5);
46511 if (!SWIG_IsOK(ecode5)) {
46512 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46513 }
46514 arg5 = static_cast< int >(val5);
46515 {
46516 PyThreadState* __tstate = wxPyBeginAllowThreads();
46517 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46518 wxPyEndAllowThreads(__tstate);
46519 if (PyErr_Occurred()) SWIG_fail;
46520 }
46521 resultobj = SWIG_Py_Void();
46522 return resultobj;
46523 fail:
46524 return NULL;
46525 }
46526
46527
46528 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46529 PyObject *resultobj = 0;
46530 wxSizer *arg1 = (wxSizer *) 0 ;
46531 wxSize *arg2 = 0 ;
46532 void *argp1 = 0 ;
46533 int res1 = 0 ;
46534 wxSize temp2 ;
46535 PyObject * obj0 = 0 ;
46536 PyObject * obj1 = 0 ;
46537 char * kwnames[] = {
46538 (char *) "self",(char *) "size", NULL
46539 };
46540
46541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46543 if (!SWIG_IsOK(res1)) {
46544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46545 }
46546 arg1 = reinterpret_cast< wxSizer * >(argp1);
46547 {
46548 arg2 = &temp2;
46549 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46550 }
46551 {
46552 PyThreadState* __tstate = wxPyBeginAllowThreads();
46553 (arg1)->SetMinSize((wxSize const &)*arg2);
46554 wxPyEndAllowThreads(__tstate);
46555 if (PyErr_Occurred()) SWIG_fail;
46556 }
46557 resultobj = SWIG_Py_Void();
46558 return resultobj;
46559 fail:
46560 return NULL;
46561 }
46562
46563
46564 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46565 PyObject *resultobj = 0;
46566 wxSizer *arg1 = (wxSizer *) 0 ;
46567 wxSize result;
46568 void *argp1 = 0 ;
46569 int res1 = 0 ;
46570 PyObject *swig_obj[1] ;
46571
46572 if (!args) SWIG_fail;
46573 swig_obj[0] = args;
46574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46575 if (!SWIG_IsOK(res1)) {
46576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46577 }
46578 arg1 = reinterpret_cast< wxSizer * >(argp1);
46579 {
46580 PyThreadState* __tstate = wxPyBeginAllowThreads();
46581 result = (arg1)->GetSize();
46582 wxPyEndAllowThreads(__tstate);
46583 if (PyErr_Occurred()) SWIG_fail;
46584 }
46585 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46586 return resultobj;
46587 fail:
46588 return NULL;
46589 }
46590
46591
46592 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46593 PyObject *resultobj = 0;
46594 wxSizer *arg1 = (wxSizer *) 0 ;
46595 wxPoint result;
46596 void *argp1 = 0 ;
46597 int res1 = 0 ;
46598 PyObject *swig_obj[1] ;
46599
46600 if (!args) SWIG_fail;
46601 swig_obj[0] = args;
46602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46603 if (!SWIG_IsOK(res1)) {
46604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46605 }
46606 arg1 = reinterpret_cast< wxSizer * >(argp1);
46607 {
46608 PyThreadState* __tstate = wxPyBeginAllowThreads();
46609 result = (arg1)->GetPosition();
46610 wxPyEndAllowThreads(__tstate);
46611 if (PyErr_Occurred()) SWIG_fail;
46612 }
46613 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46614 return resultobj;
46615 fail:
46616 return NULL;
46617 }
46618
46619
46620 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46621 PyObject *resultobj = 0;
46622 wxSizer *arg1 = (wxSizer *) 0 ;
46623 wxSize result;
46624 void *argp1 = 0 ;
46625 int res1 = 0 ;
46626 PyObject *swig_obj[1] ;
46627
46628 if (!args) SWIG_fail;
46629 swig_obj[0] = args;
46630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46631 if (!SWIG_IsOK(res1)) {
46632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46633 }
46634 arg1 = reinterpret_cast< wxSizer * >(argp1);
46635 {
46636 PyThreadState* __tstate = wxPyBeginAllowThreads();
46637 result = (arg1)->GetMinSize();
46638 wxPyEndAllowThreads(__tstate);
46639 if (PyErr_Occurred()) SWIG_fail;
46640 }
46641 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46642 return resultobj;
46643 fail:
46644 return NULL;
46645 }
46646
46647
46648 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46649 PyObject *resultobj = 0;
46650 wxSizer *arg1 = (wxSizer *) 0 ;
46651 void *argp1 = 0 ;
46652 int res1 = 0 ;
46653 PyObject *swig_obj[1] ;
46654
46655 if (!args) SWIG_fail;
46656 swig_obj[0] = args;
46657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46658 if (!SWIG_IsOK(res1)) {
46659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46660 }
46661 arg1 = reinterpret_cast< wxSizer * >(argp1);
46662 {
46663 PyThreadState* __tstate = wxPyBeginAllowThreads();
46664 (arg1)->RecalcSizes();
46665 wxPyEndAllowThreads(__tstate);
46666 if (PyErr_Occurred()) SWIG_fail;
46667 }
46668 resultobj = SWIG_Py_Void();
46669 return resultobj;
46670 fail:
46671 return NULL;
46672 }
46673
46674
46675 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46676 PyObject *resultobj = 0;
46677 wxSizer *arg1 = (wxSizer *) 0 ;
46678 wxSize result;
46679 void *argp1 = 0 ;
46680 int res1 = 0 ;
46681 PyObject *swig_obj[1] ;
46682
46683 if (!args) SWIG_fail;
46684 swig_obj[0] = args;
46685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46686 if (!SWIG_IsOK(res1)) {
46687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46688 }
46689 arg1 = reinterpret_cast< wxSizer * >(argp1);
46690 {
46691 PyThreadState* __tstate = wxPyBeginAllowThreads();
46692 result = (arg1)->CalcMin();
46693 wxPyEndAllowThreads(__tstate);
46694 if (PyErr_Occurred()) SWIG_fail;
46695 }
46696 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46697 return resultobj;
46698 fail:
46699 return NULL;
46700 }
46701
46702
46703 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46704 PyObject *resultobj = 0;
46705 wxSizer *arg1 = (wxSizer *) 0 ;
46706 void *argp1 = 0 ;
46707 int res1 = 0 ;
46708 PyObject *swig_obj[1] ;
46709
46710 if (!args) SWIG_fail;
46711 swig_obj[0] = args;
46712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46713 if (!SWIG_IsOK(res1)) {
46714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46715 }
46716 arg1 = reinterpret_cast< wxSizer * >(argp1);
46717 {
46718 PyThreadState* __tstate = wxPyBeginAllowThreads();
46719 (arg1)->Layout();
46720 wxPyEndAllowThreads(__tstate);
46721 if (PyErr_Occurred()) SWIG_fail;
46722 }
46723 resultobj = SWIG_Py_Void();
46724 return resultobj;
46725 fail:
46726 return NULL;
46727 }
46728
46729
46730 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46731 PyObject *resultobj = 0;
46732 wxSizer *arg1 = (wxSizer *) 0 ;
46733 wxWindow *arg2 = (wxWindow *) 0 ;
46734 wxSize result;
46735 void *argp1 = 0 ;
46736 int res1 = 0 ;
46737 void *argp2 = 0 ;
46738 int res2 = 0 ;
46739 PyObject * obj0 = 0 ;
46740 PyObject * obj1 = 0 ;
46741 char * kwnames[] = {
46742 (char *) "self",(char *) "window", NULL
46743 };
46744
46745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46747 if (!SWIG_IsOK(res1)) {
46748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46749 }
46750 arg1 = reinterpret_cast< wxSizer * >(argp1);
46751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46752 if (!SWIG_IsOK(res2)) {
46753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46754 }
46755 arg2 = reinterpret_cast< wxWindow * >(argp2);
46756 {
46757 PyThreadState* __tstate = wxPyBeginAllowThreads();
46758 result = (arg1)->Fit(arg2);
46759 wxPyEndAllowThreads(__tstate);
46760 if (PyErr_Occurred()) SWIG_fail;
46761 }
46762 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46763 return resultobj;
46764 fail:
46765 return NULL;
46766 }
46767
46768
46769 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46770 PyObject *resultobj = 0;
46771 wxSizer *arg1 = (wxSizer *) 0 ;
46772 wxWindow *arg2 = (wxWindow *) 0 ;
46773 void *argp1 = 0 ;
46774 int res1 = 0 ;
46775 void *argp2 = 0 ;
46776 int res2 = 0 ;
46777 PyObject * obj0 = 0 ;
46778 PyObject * obj1 = 0 ;
46779 char * kwnames[] = {
46780 (char *) "self",(char *) "window", NULL
46781 };
46782
46783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46785 if (!SWIG_IsOK(res1)) {
46786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46787 }
46788 arg1 = reinterpret_cast< wxSizer * >(argp1);
46789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46790 if (!SWIG_IsOK(res2)) {
46791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46792 }
46793 arg2 = reinterpret_cast< wxWindow * >(argp2);
46794 {
46795 PyThreadState* __tstate = wxPyBeginAllowThreads();
46796 (arg1)->FitInside(arg2);
46797 wxPyEndAllowThreads(__tstate);
46798 if (PyErr_Occurred()) SWIG_fail;
46799 }
46800 resultobj = SWIG_Py_Void();
46801 return resultobj;
46802 fail:
46803 return NULL;
46804 }
46805
46806
46807 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46808 PyObject *resultobj = 0;
46809 wxSizer *arg1 = (wxSizer *) 0 ;
46810 wxWindow *arg2 = (wxWindow *) 0 ;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 void *argp2 = 0 ;
46814 int res2 = 0 ;
46815 PyObject * obj0 = 0 ;
46816 PyObject * obj1 = 0 ;
46817 char * kwnames[] = {
46818 (char *) "self",(char *) "window", NULL
46819 };
46820
46821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46823 if (!SWIG_IsOK(res1)) {
46824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46825 }
46826 arg1 = reinterpret_cast< wxSizer * >(argp1);
46827 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46828 if (!SWIG_IsOK(res2)) {
46829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46830 }
46831 arg2 = reinterpret_cast< wxWindow * >(argp2);
46832 {
46833 PyThreadState* __tstate = wxPyBeginAllowThreads();
46834 (arg1)->SetSizeHints(arg2);
46835 wxPyEndAllowThreads(__tstate);
46836 if (PyErr_Occurred()) SWIG_fail;
46837 }
46838 resultobj = SWIG_Py_Void();
46839 return resultobj;
46840 fail:
46841 return NULL;
46842 }
46843
46844
46845 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46846 PyObject *resultobj = 0;
46847 wxSizer *arg1 = (wxSizer *) 0 ;
46848 wxWindow *arg2 = (wxWindow *) 0 ;
46849 void *argp1 = 0 ;
46850 int res1 = 0 ;
46851 void *argp2 = 0 ;
46852 int res2 = 0 ;
46853 PyObject * obj0 = 0 ;
46854 PyObject * obj1 = 0 ;
46855 char * kwnames[] = {
46856 (char *) "self",(char *) "window", NULL
46857 };
46858
46859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46861 if (!SWIG_IsOK(res1)) {
46862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46863 }
46864 arg1 = reinterpret_cast< wxSizer * >(argp1);
46865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46866 if (!SWIG_IsOK(res2)) {
46867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46868 }
46869 arg2 = reinterpret_cast< wxWindow * >(argp2);
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 (arg1)->SetVirtualSizeHints(arg2);
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 resultobj = SWIG_Py_Void();
46877 return resultobj;
46878 fail:
46879 return NULL;
46880 }
46881
46882
46883 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46884 PyObject *resultobj = 0;
46885 wxSizer *arg1 = (wxSizer *) 0 ;
46886 bool arg2 = (bool) false ;
46887 void *argp1 = 0 ;
46888 int res1 = 0 ;
46889 bool val2 ;
46890 int ecode2 = 0 ;
46891 PyObject * obj0 = 0 ;
46892 PyObject * obj1 = 0 ;
46893 char * kwnames[] = {
46894 (char *) "self",(char *) "deleteWindows", NULL
46895 };
46896
46897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46899 if (!SWIG_IsOK(res1)) {
46900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46901 }
46902 arg1 = reinterpret_cast< wxSizer * >(argp1);
46903 if (obj1) {
46904 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46905 if (!SWIG_IsOK(ecode2)) {
46906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46907 }
46908 arg2 = static_cast< bool >(val2);
46909 }
46910 {
46911 PyThreadState* __tstate = wxPyBeginAllowThreads();
46912 (arg1)->Clear(arg2);
46913 wxPyEndAllowThreads(__tstate);
46914 if (PyErr_Occurred()) SWIG_fail;
46915 }
46916 resultobj = SWIG_Py_Void();
46917 return resultobj;
46918 fail:
46919 return NULL;
46920 }
46921
46922
46923 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46924 PyObject *resultobj = 0;
46925 wxSizer *arg1 = (wxSizer *) 0 ;
46926 void *argp1 = 0 ;
46927 int res1 = 0 ;
46928 PyObject *swig_obj[1] ;
46929
46930 if (!args) SWIG_fail;
46931 swig_obj[0] = args;
46932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46933 if (!SWIG_IsOK(res1)) {
46934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46935 }
46936 arg1 = reinterpret_cast< wxSizer * >(argp1);
46937 {
46938 PyThreadState* __tstate = wxPyBeginAllowThreads();
46939 (arg1)->DeleteWindows();
46940 wxPyEndAllowThreads(__tstate);
46941 if (PyErr_Occurred()) SWIG_fail;
46942 }
46943 resultobj = SWIG_Py_Void();
46944 return resultobj;
46945 fail:
46946 return NULL;
46947 }
46948
46949
46950 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46951 PyObject *resultobj = 0;
46952 wxSizer *arg1 = (wxSizer *) 0 ;
46953 PyObject *result = 0 ;
46954 void *argp1 = 0 ;
46955 int res1 = 0 ;
46956 PyObject *swig_obj[1] ;
46957
46958 if (!args) SWIG_fail;
46959 swig_obj[0] = args;
46960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46961 if (!SWIG_IsOK(res1)) {
46962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46963 }
46964 arg1 = reinterpret_cast< wxSizer * >(argp1);
46965 {
46966 PyThreadState* __tstate = wxPyBeginAllowThreads();
46967 result = (PyObject *)wxSizer_GetChildren(arg1);
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 resultobj = result;
46972 return resultobj;
46973 fail:
46974 return NULL;
46975 }
46976
46977
46978 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46979 PyObject *resultobj = 0;
46980 wxSizer *arg1 = (wxSizer *) 0 ;
46981 PyObject *arg2 = (PyObject *) 0 ;
46982 bool arg3 = (bool) true ;
46983 bool arg4 = (bool) false ;
46984 bool result;
46985 void *argp1 = 0 ;
46986 int res1 = 0 ;
46987 bool val3 ;
46988 int ecode3 = 0 ;
46989 bool val4 ;
46990 int ecode4 = 0 ;
46991 PyObject * obj0 = 0 ;
46992 PyObject * obj1 = 0 ;
46993 PyObject * obj2 = 0 ;
46994 PyObject * obj3 = 0 ;
46995 char * kwnames[] = {
46996 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46997 };
46998
46999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47001 if (!SWIG_IsOK(res1)) {
47002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47003 }
47004 arg1 = reinterpret_cast< wxSizer * >(argp1);
47005 arg2 = obj1;
47006 if (obj2) {
47007 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47008 if (!SWIG_IsOK(ecode3)) {
47009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47010 }
47011 arg3 = static_cast< bool >(val3);
47012 }
47013 if (obj3) {
47014 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47015 if (!SWIG_IsOK(ecode4)) {
47016 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47017 }
47018 arg4 = static_cast< bool >(val4);
47019 }
47020 {
47021 PyThreadState* __tstate = wxPyBeginAllowThreads();
47022 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47023 wxPyEndAllowThreads(__tstate);
47024 if (PyErr_Occurred()) SWIG_fail;
47025 }
47026 {
47027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47028 }
47029 return resultobj;
47030 fail:
47031 return NULL;
47032 }
47033
47034
47035 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47036 PyObject *resultobj = 0;
47037 wxSizer *arg1 = (wxSizer *) 0 ;
47038 PyObject *arg2 = (PyObject *) 0 ;
47039 bool result;
47040 void *argp1 = 0 ;
47041 int res1 = 0 ;
47042 PyObject * obj0 = 0 ;
47043 PyObject * obj1 = 0 ;
47044 char * kwnames[] = {
47045 (char *) "self",(char *) "item", NULL
47046 };
47047
47048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47050 if (!SWIG_IsOK(res1)) {
47051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47052 }
47053 arg1 = reinterpret_cast< wxSizer * >(argp1);
47054 arg2 = obj1;
47055 {
47056 PyThreadState* __tstate = wxPyBeginAllowThreads();
47057 result = (bool)wxSizer_IsShown(arg1,arg2);
47058 wxPyEndAllowThreads(__tstate);
47059 if (PyErr_Occurred()) SWIG_fail;
47060 }
47061 {
47062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47063 }
47064 return resultobj;
47065 fail:
47066 return NULL;
47067 }
47068
47069
47070 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47071 PyObject *resultobj = 0;
47072 wxSizer *arg1 = (wxSizer *) 0 ;
47073 bool arg2 ;
47074 void *argp1 = 0 ;
47075 int res1 = 0 ;
47076 bool val2 ;
47077 int ecode2 = 0 ;
47078 PyObject * obj0 = 0 ;
47079 PyObject * obj1 = 0 ;
47080 char * kwnames[] = {
47081 (char *) "self",(char *) "show", NULL
47082 };
47083
47084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47086 if (!SWIG_IsOK(res1)) {
47087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47088 }
47089 arg1 = reinterpret_cast< wxSizer * >(argp1);
47090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47091 if (!SWIG_IsOK(ecode2)) {
47092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47093 }
47094 arg2 = static_cast< bool >(val2);
47095 {
47096 PyThreadState* __tstate = wxPyBeginAllowThreads();
47097 (arg1)->ShowItems(arg2);
47098 wxPyEndAllowThreads(__tstate);
47099 if (PyErr_Occurred()) SWIG_fail;
47100 }
47101 resultobj = SWIG_Py_Void();
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47109 PyObject *obj;
47110 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47111 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47112 return SWIG_Py_Void();
47113 }
47114
47115 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47116 PyObject *resultobj = 0;
47117 wxPySizer *result = 0 ;
47118
47119 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47120 {
47121 PyThreadState* __tstate = wxPyBeginAllowThreads();
47122 result = (wxPySizer *)new wxPySizer();
47123 wxPyEndAllowThreads(__tstate);
47124 if (PyErr_Occurred()) SWIG_fail;
47125 }
47126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47127 return resultobj;
47128 fail:
47129 return NULL;
47130 }
47131
47132
47133 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47134 PyObject *resultobj = 0;
47135 wxPySizer *arg1 = (wxPySizer *) 0 ;
47136 PyObject *arg2 = (PyObject *) 0 ;
47137 PyObject *arg3 = (PyObject *) 0 ;
47138 void *argp1 = 0 ;
47139 int res1 = 0 ;
47140 PyObject * obj0 = 0 ;
47141 PyObject * obj1 = 0 ;
47142 PyObject * obj2 = 0 ;
47143 char * kwnames[] = {
47144 (char *) "self",(char *) "self",(char *) "_class", NULL
47145 };
47146
47147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47149 if (!SWIG_IsOK(res1)) {
47150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47151 }
47152 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47153 arg2 = obj1;
47154 arg3 = obj2;
47155 {
47156 PyThreadState* __tstate = wxPyBeginAllowThreads();
47157 (arg1)->_setCallbackInfo(arg2,arg3);
47158 wxPyEndAllowThreads(__tstate);
47159 if (PyErr_Occurred()) SWIG_fail;
47160 }
47161 resultobj = SWIG_Py_Void();
47162 return resultobj;
47163 fail:
47164 return NULL;
47165 }
47166
47167
47168 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47169 PyObject *obj;
47170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47171 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47172 return SWIG_Py_Void();
47173 }
47174
47175 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47176 return SWIG_Python_InitShadowInstance(args);
47177 }
47178
47179 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47180 PyObject *resultobj = 0;
47181 int arg1 = (int) wxHORIZONTAL ;
47182 wxBoxSizer *result = 0 ;
47183 int val1 ;
47184 int ecode1 = 0 ;
47185 PyObject * obj0 = 0 ;
47186 char * kwnames[] = {
47187 (char *) "orient", NULL
47188 };
47189
47190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47191 if (obj0) {
47192 ecode1 = SWIG_AsVal_int(obj0, &val1);
47193 if (!SWIG_IsOK(ecode1)) {
47194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47195 }
47196 arg1 = static_cast< int >(val1);
47197 }
47198 {
47199 PyThreadState* __tstate = wxPyBeginAllowThreads();
47200 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47201 wxPyEndAllowThreads(__tstate);
47202 if (PyErr_Occurred()) SWIG_fail;
47203 }
47204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47205 return resultobj;
47206 fail:
47207 return NULL;
47208 }
47209
47210
47211 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47212 PyObject *resultobj = 0;
47213 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47214 int result;
47215 void *argp1 = 0 ;
47216 int res1 = 0 ;
47217 PyObject *swig_obj[1] ;
47218
47219 if (!args) SWIG_fail;
47220 swig_obj[0] = args;
47221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47222 if (!SWIG_IsOK(res1)) {
47223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47224 }
47225 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47226 {
47227 PyThreadState* __tstate = wxPyBeginAllowThreads();
47228 result = (int)(arg1)->GetOrientation();
47229 wxPyEndAllowThreads(__tstate);
47230 if (PyErr_Occurred()) SWIG_fail;
47231 }
47232 resultobj = SWIG_From_int(static_cast< int >(result));
47233 return resultobj;
47234 fail:
47235 return NULL;
47236 }
47237
47238
47239 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47240 PyObject *resultobj = 0;
47241 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47242 int arg2 ;
47243 void *argp1 = 0 ;
47244 int res1 = 0 ;
47245 int val2 ;
47246 int ecode2 = 0 ;
47247 PyObject * obj0 = 0 ;
47248 PyObject * obj1 = 0 ;
47249 char * kwnames[] = {
47250 (char *) "self",(char *) "orient", NULL
47251 };
47252
47253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47255 if (!SWIG_IsOK(res1)) {
47256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47257 }
47258 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47259 ecode2 = SWIG_AsVal_int(obj1, &val2);
47260 if (!SWIG_IsOK(ecode2)) {
47261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47262 }
47263 arg2 = static_cast< int >(val2);
47264 {
47265 PyThreadState* __tstate = wxPyBeginAllowThreads();
47266 (arg1)->SetOrientation(arg2);
47267 wxPyEndAllowThreads(__tstate);
47268 if (PyErr_Occurred()) SWIG_fail;
47269 }
47270 resultobj = SWIG_Py_Void();
47271 return resultobj;
47272 fail:
47273 return NULL;
47274 }
47275
47276
47277 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47278 PyObject *obj;
47279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47280 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47281 return SWIG_Py_Void();
47282 }
47283
47284 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47285 return SWIG_Python_InitShadowInstance(args);
47286 }
47287
47288 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47289 PyObject *resultobj = 0;
47290 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47291 int arg2 = (int) wxHORIZONTAL ;
47292 wxStaticBoxSizer *result = 0 ;
47293 void *argp1 = 0 ;
47294 int res1 = 0 ;
47295 int val2 ;
47296 int ecode2 = 0 ;
47297 PyObject * obj0 = 0 ;
47298 PyObject * obj1 = 0 ;
47299 char * kwnames[] = {
47300 (char *) "box",(char *) "orient", NULL
47301 };
47302
47303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47305 if (!SWIG_IsOK(res1)) {
47306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47307 }
47308 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47309 if (obj1) {
47310 ecode2 = SWIG_AsVal_int(obj1, &val2);
47311 if (!SWIG_IsOK(ecode2)) {
47312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47313 }
47314 arg2 = static_cast< int >(val2);
47315 }
47316 {
47317 PyThreadState* __tstate = wxPyBeginAllowThreads();
47318 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47319 wxPyEndAllowThreads(__tstate);
47320 if (PyErr_Occurred()) SWIG_fail;
47321 }
47322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47323 return resultobj;
47324 fail:
47325 return NULL;
47326 }
47327
47328
47329 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47330 PyObject *resultobj = 0;
47331 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47332 wxStaticBox *result = 0 ;
47333 void *argp1 = 0 ;
47334 int res1 = 0 ;
47335 PyObject *swig_obj[1] ;
47336
47337 if (!args) SWIG_fail;
47338 swig_obj[0] = args;
47339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47340 if (!SWIG_IsOK(res1)) {
47341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47342 }
47343 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47344 {
47345 PyThreadState* __tstate = wxPyBeginAllowThreads();
47346 result = (wxStaticBox *)(arg1)->GetStaticBox();
47347 wxPyEndAllowThreads(__tstate);
47348 if (PyErr_Occurred()) SWIG_fail;
47349 }
47350 {
47351 resultobj = wxPyMake_wxObject(result, (bool)0);
47352 }
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *obj;
47361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47362 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47363 return SWIG_Py_Void();
47364 }
47365
47366 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47367 return SWIG_Python_InitShadowInstance(args);
47368 }
47369
47370 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47371 PyObject *resultobj = 0;
47372 int arg1 = (int) 1 ;
47373 int arg2 = (int) 0 ;
47374 int arg3 = (int) 0 ;
47375 int arg4 = (int) 0 ;
47376 wxGridSizer *result = 0 ;
47377 int val1 ;
47378 int ecode1 = 0 ;
47379 int val2 ;
47380 int ecode2 = 0 ;
47381 int val3 ;
47382 int ecode3 = 0 ;
47383 int val4 ;
47384 int ecode4 = 0 ;
47385 PyObject * obj0 = 0 ;
47386 PyObject * obj1 = 0 ;
47387 PyObject * obj2 = 0 ;
47388 PyObject * obj3 = 0 ;
47389 char * kwnames[] = {
47390 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47391 };
47392
47393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47394 if (obj0) {
47395 ecode1 = SWIG_AsVal_int(obj0, &val1);
47396 if (!SWIG_IsOK(ecode1)) {
47397 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47398 }
47399 arg1 = static_cast< int >(val1);
47400 }
47401 if (obj1) {
47402 ecode2 = SWIG_AsVal_int(obj1, &val2);
47403 if (!SWIG_IsOK(ecode2)) {
47404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47405 }
47406 arg2 = static_cast< int >(val2);
47407 }
47408 if (obj2) {
47409 ecode3 = SWIG_AsVal_int(obj2, &val3);
47410 if (!SWIG_IsOK(ecode3)) {
47411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47412 }
47413 arg3 = static_cast< int >(val3);
47414 }
47415 if (obj3) {
47416 ecode4 = SWIG_AsVal_int(obj3, &val4);
47417 if (!SWIG_IsOK(ecode4)) {
47418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47419 }
47420 arg4 = static_cast< int >(val4);
47421 }
47422 {
47423 PyThreadState* __tstate = wxPyBeginAllowThreads();
47424 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47425 wxPyEndAllowThreads(__tstate);
47426 if (PyErr_Occurred()) SWIG_fail;
47427 }
47428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47429 return resultobj;
47430 fail:
47431 return NULL;
47432 }
47433
47434
47435 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47436 PyObject *resultobj = 0;
47437 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47438 int arg2 ;
47439 void *argp1 = 0 ;
47440 int res1 = 0 ;
47441 int val2 ;
47442 int ecode2 = 0 ;
47443 PyObject * obj0 = 0 ;
47444 PyObject * obj1 = 0 ;
47445 char * kwnames[] = {
47446 (char *) "self",(char *) "cols", NULL
47447 };
47448
47449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47451 if (!SWIG_IsOK(res1)) {
47452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47453 }
47454 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47455 ecode2 = SWIG_AsVal_int(obj1, &val2);
47456 if (!SWIG_IsOK(ecode2)) {
47457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47458 }
47459 arg2 = static_cast< int >(val2);
47460 {
47461 PyThreadState* __tstate = wxPyBeginAllowThreads();
47462 (arg1)->SetCols(arg2);
47463 wxPyEndAllowThreads(__tstate);
47464 if (PyErr_Occurred()) SWIG_fail;
47465 }
47466 resultobj = SWIG_Py_Void();
47467 return resultobj;
47468 fail:
47469 return NULL;
47470 }
47471
47472
47473 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47474 PyObject *resultobj = 0;
47475 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47476 int arg2 ;
47477 void *argp1 = 0 ;
47478 int res1 = 0 ;
47479 int val2 ;
47480 int ecode2 = 0 ;
47481 PyObject * obj0 = 0 ;
47482 PyObject * obj1 = 0 ;
47483 char * kwnames[] = {
47484 (char *) "self",(char *) "rows", NULL
47485 };
47486
47487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47489 if (!SWIG_IsOK(res1)) {
47490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47491 }
47492 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47493 ecode2 = SWIG_AsVal_int(obj1, &val2);
47494 if (!SWIG_IsOK(ecode2)) {
47495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47496 }
47497 arg2 = static_cast< int >(val2);
47498 {
47499 PyThreadState* __tstate = wxPyBeginAllowThreads();
47500 (arg1)->SetRows(arg2);
47501 wxPyEndAllowThreads(__tstate);
47502 if (PyErr_Occurred()) SWIG_fail;
47503 }
47504 resultobj = SWIG_Py_Void();
47505 return resultobj;
47506 fail:
47507 return NULL;
47508 }
47509
47510
47511 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47512 PyObject *resultobj = 0;
47513 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47514 int arg2 ;
47515 void *argp1 = 0 ;
47516 int res1 = 0 ;
47517 int val2 ;
47518 int ecode2 = 0 ;
47519 PyObject * obj0 = 0 ;
47520 PyObject * obj1 = 0 ;
47521 char * kwnames[] = {
47522 (char *) "self",(char *) "gap", NULL
47523 };
47524
47525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47527 if (!SWIG_IsOK(res1)) {
47528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47529 }
47530 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47531 ecode2 = SWIG_AsVal_int(obj1, &val2);
47532 if (!SWIG_IsOK(ecode2)) {
47533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47534 }
47535 arg2 = static_cast< int >(val2);
47536 {
47537 PyThreadState* __tstate = wxPyBeginAllowThreads();
47538 (arg1)->SetVGap(arg2);
47539 wxPyEndAllowThreads(__tstate);
47540 if (PyErr_Occurred()) SWIG_fail;
47541 }
47542 resultobj = SWIG_Py_Void();
47543 return resultobj;
47544 fail:
47545 return NULL;
47546 }
47547
47548
47549 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47550 PyObject *resultobj = 0;
47551 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47552 int arg2 ;
47553 void *argp1 = 0 ;
47554 int res1 = 0 ;
47555 int val2 ;
47556 int ecode2 = 0 ;
47557 PyObject * obj0 = 0 ;
47558 PyObject * obj1 = 0 ;
47559 char * kwnames[] = {
47560 (char *) "self",(char *) "gap", NULL
47561 };
47562
47563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47565 if (!SWIG_IsOK(res1)) {
47566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47567 }
47568 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47569 ecode2 = SWIG_AsVal_int(obj1, &val2);
47570 if (!SWIG_IsOK(ecode2)) {
47571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47572 }
47573 arg2 = static_cast< int >(val2);
47574 {
47575 PyThreadState* __tstate = wxPyBeginAllowThreads();
47576 (arg1)->SetHGap(arg2);
47577 wxPyEndAllowThreads(__tstate);
47578 if (PyErr_Occurred()) SWIG_fail;
47579 }
47580 resultobj = SWIG_Py_Void();
47581 return resultobj;
47582 fail:
47583 return NULL;
47584 }
47585
47586
47587 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47588 PyObject *resultobj = 0;
47589 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47590 int result;
47591 void *argp1 = 0 ;
47592 int res1 = 0 ;
47593 PyObject *swig_obj[1] ;
47594
47595 if (!args) SWIG_fail;
47596 swig_obj[0] = args;
47597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47598 if (!SWIG_IsOK(res1)) {
47599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47600 }
47601 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47602 {
47603 PyThreadState* __tstate = wxPyBeginAllowThreads();
47604 result = (int)(arg1)->GetCols();
47605 wxPyEndAllowThreads(__tstate);
47606 if (PyErr_Occurred()) SWIG_fail;
47607 }
47608 resultobj = SWIG_From_int(static_cast< int >(result));
47609 return resultobj;
47610 fail:
47611 return NULL;
47612 }
47613
47614
47615 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47616 PyObject *resultobj = 0;
47617 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47618 int result;
47619 void *argp1 = 0 ;
47620 int res1 = 0 ;
47621 PyObject *swig_obj[1] ;
47622
47623 if (!args) SWIG_fail;
47624 swig_obj[0] = args;
47625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47626 if (!SWIG_IsOK(res1)) {
47627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47628 }
47629 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47630 {
47631 PyThreadState* __tstate = wxPyBeginAllowThreads();
47632 result = (int)(arg1)->GetRows();
47633 wxPyEndAllowThreads(__tstate);
47634 if (PyErr_Occurred()) SWIG_fail;
47635 }
47636 resultobj = SWIG_From_int(static_cast< int >(result));
47637 return resultobj;
47638 fail:
47639 return NULL;
47640 }
47641
47642
47643 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47644 PyObject *resultobj = 0;
47645 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47646 int result;
47647 void *argp1 = 0 ;
47648 int res1 = 0 ;
47649 PyObject *swig_obj[1] ;
47650
47651 if (!args) SWIG_fail;
47652 swig_obj[0] = args;
47653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47654 if (!SWIG_IsOK(res1)) {
47655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47656 }
47657 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47658 {
47659 PyThreadState* __tstate = wxPyBeginAllowThreads();
47660 result = (int)(arg1)->GetVGap();
47661 wxPyEndAllowThreads(__tstate);
47662 if (PyErr_Occurred()) SWIG_fail;
47663 }
47664 resultobj = SWIG_From_int(static_cast< int >(result));
47665 return resultobj;
47666 fail:
47667 return NULL;
47668 }
47669
47670
47671 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47672 PyObject *resultobj = 0;
47673 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47674 int result;
47675 void *argp1 = 0 ;
47676 int res1 = 0 ;
47677 PyObject *swig_obj[1] ;
47678
47679 if (!args) SWIG_fail;
47680 swig_obj[0] = args;
47681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47682 if (!SWIG_IsOK(res1)) {
47683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47684 }
47685 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47686 {
47687 PyThreadState* __tstate = wxPyBeginAllowThreads();
47688 result = (int)(arg1)->GetHGap();
47689 wxPyEndAllowThreads(__tstate);
47690 if (PyErr_Occurred()) SWIG_fail;
47691 }
47692 resultobj = SWIG_From_int(static_cast< int >(result));
47693 return resultobj;
47694 fail:
47695 return NULL;
47696 }
47697
47698
47699 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47700 PyObject *obj;
47701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47702 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47703 return SWIG_Py_Void();
47704 }
47705
47706 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47707 return SWIG_Python_InitShadowInstance(args);
47708 }
47709
47710 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47711 PyObject *resultobj = 0;
47712 int arg1 = (int) 1 ;
47713 int arg2 = (int) 0 ;
47714 int arg3 = (int) 0 ;
47715 int arg4 = (int) 0 ;
47716 wxFlexGridSizer *result = 0 ;
47717 int val1 ;
47718 int ecode1 = 0 ;
47719 int val2 ;
47720 int ecode2 = 0 ;
47721 int val3 ;
47722 int ecode3 = 0 ;
47723 int val4 ;
47724 int ecode4 = 0 ;
47725 PyObject * obj0 = 0 ;
47726 PyObject * obj1 = 0 ;
47727 PyObject * obj2 = 0 ;
47728 PyObject * obj3 = 0 ;
47729 char * kwnames[] = {
47730 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47731 };
47732
47733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47734 if (obj0) {
47735 ecode1 = SWIG_AsVal_int(obj0, &val1);
47736 if (!SWIG_IsOK(ecode1)) {
47737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47738 }
47739 arg1 = static_cast< int >(val1);
47740 }
47741 if (obj1) {
47742 ecode2 = SWIG_AsVal_int(obj1, &val2);
47743 if (!SWIG_IsOK(ecode2)) {
47744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47745 }
47746 arg2 = static_cast< int >(val2);
47747 }
47748 if (obj2) {
47749 ecode3 = SWIG_AsVal_int(obj2, &val3);
47750 if (!SWIG_IsOK(ecode3)) {
47751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47752 }
47753 arg3 = static_cast< int >(val3);
47754 }
47755 if (obj3) {
47756 ecode4 = SWIG_AsVal_int(obj3, &val4);
47757 if (!SWIG_IsOK(ecode4)) {
47758 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47759 }
47760 arg4 = static_cast< int >(val4);
47761 }
47762 {
47763 PyThreadState* __tstate = wxPyBeginAllowThreads();
47764 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47765 wxPyEndAllowThreads(__tstate);
47766 if (PyErr_Occurred()) SWIG_fail;
47767 }
47768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47769 return resultobj;
47770 fail:
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47776 PyObject *resultobj = 0;
47777 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47778 size_t arg2 ;
47779 int arg3 = (int) 0 ;
47780 void *argp1 = 0 ;
47781 int res1 = 0 ;
47782 size_t val2 ;
47783 int ecode2 = 0 ;
47784 int val3 ;
47785 int ecode3 = 0 ;
47786 PyObject * obj0 = 0 ;
47787 PyObject * obj1 = 0 ;
47788 PyObject * obj2 = 0 ;
47789 char * kwnames[] = {
47790 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47791 };
47792
47793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47795 if (!SWIG_IsOK(res1)) {
47796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47797 }
47798 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47799 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47800 if (!SWIG_IsOK(ecode2)) {
47801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47802 }
47803 arg2 = static_cast< size_t >(val2);
47804 if (obj2) {
47805 ecode3 = SWIG_AsVal_int(obj2, &val3);
47806 if (!SWIG_IsOK(ecode3)) {
47807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47808 }
47809 arg3 = static_cast< int >(val3);
47810 }
47811 {
47812 PyThreadState* __tstate = wxPyBeginAllowThreads();
47813 (arg1)->AddGrowableRow(arg2,arg3);
47814 wxPyEndAllowThreads(__tstate);
47815 if (PyErr_Occurred()) SWIG_fail;
47816 }
47817 resultobj = SWIG_Py_Void();
47818 return resultobj;
47819 fail:
47820 return NULL;
47821 }
47822
47823
47824 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47825 PyObject *resultobj = 0;
47826 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47827 size_t arg2 ;
47828 void *argp1 = 0 ;
47829 int res1 = 0 ;
47830 size_t val2 ;
47831 int ecode2 = 0 ;
47832 PyObject * obj0 = 0 ;
47833 PyObject * obj1 = 0 ;
47834 char * kwnames[] = {
47835 (char *) "self",(char *) "idx", NULL
47836 };
47837
47838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47840 if (!SWIG_IsOK(res1)) {
47841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47842 }
47843 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47844 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47845 if (!SWIG_IsOK(ecode2)) {
47846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47847 }
47848 arg2 = static_cast< size_t >(val2);
47849 {
47850 PyThreadState* __tstate = wxPyBeginAllowThreads();
47851 (arg1)->RemoveGrowableRow(arg2);
47852 wxPyEndAllowThreads(__tstate);
47853 if (PyErr_Occurred()) SWIG_fail;
47854 }
47855 resultobj = SWIG_Py_Void();
47856 return resultobj;
47857 fail:
47858 return NULL;
47859 }
47860
47861
47862 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47863 PyObject *resultobj = 0;
47864 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47865 size_t arg2 ;
47866 int arg3 = (int) 0 ;
47867 void *argp1 = 0 ;
47868 int res1 = 0 ;
47869 size_t val2 ;
47870 int ecode2 = 0 ;
47871 int val3 ;
47872 int ecode3 = 0 ;
47873 PyObject * obj0 = 0 ;
47874 PyObject * obj1 = 0 ;
47875 PyObject * obj2 = 0 ;
47876 char * kwnames[] = {
47877 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47878 };
47879
47880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47882 if (!SWIG_IsOK(res1)) {
47883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47884 }
47885 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47886 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47887 if (!SWIG_IsOK(ecode2)) {
47888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47889 }
47890 arg2 = static_cast< size_t >(val2);
47891 if (obj2) {
47892 ecode3 = SWIG_AsVal_int(obj2, &val3);
47893 if (!SWIG_IsOK(ecode3)) {
47894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47895 }
47896 arg3 = static_cast< int >(val3);
47897 }
47898 {
47899 PyThreadState* __tstate = wxPyBeginAllowThreads();
47900 (arg1)->AddGrowableCol(arg2,arg3);
47901 wxPyEndAllowThreads(__tstate);
47902 if (PyErr_Occurred()) SWIG_fail;
47903 }
47904 resultobj = SWIG_Py_Void();
47905 return resultobj;
47906 fail:
47907 return NULL;
47908 }
47909
47910
47911 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47912 PyObject *resultobj = 0;
47913 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47914 size_t arg2 ;
47915 void *argp1 = 0 ;
47916 int res1 = 0 ;
47917 size_t val2 ;
47918 int ecode2 = 0 ;
47919 PyObject * obj0 = 0 ;
47920 PyObject * obj1 = 0 ;
47921 char * kwnames[] = {
47922 (char *) "self",(char *) "idx", NULL
47923 };
47924
47925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47927 if (!SWIG_IsOK(res1)) {
47928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47929 }
47930 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47931 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47932 if (!SWIG_IsOK(ecode2)) {
47933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47934 }
47935 arg2 = static_cast< size_t >(val2);
47936 {
47937 PyThreadState* __tstate = wxPyBeginAllowThreads();
47938 (arg1)->RemoveGrowableCol(arg2);
47939 wxPyEndAllowThreads(__tstate);
47940 if (PyErr_Occurred()) SWIG_fail;
47941 }
47942 resultobj = SWIG_Py_Void();
47943 return resultobj;
47944 fail:
47945 return NULL;
47946 }
47947
47948
47949 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47950 PyObject *resultobj = 0;
47951 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47952 int arg2 ;
47953 void *argp1 = 0 ;
47954 int res1 = 0 ;
47955 int val2 ;
47956 int ecode2 = 0 ;
47957 PyObject * obj0 = 0 ;
47958 PyObject * obj1 = 0 ;
47959 char * kwnames[] = {
47960 (char *) "self",(char *) "direction", NULL
47961 };
47962
47963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47965 if (!SWIG_IsOK(res1)) {
47966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47967 }
47968 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47969 ecode2 = SWIG_AsVal_int(obj1, &val2);
47970 if (!SWIG_IsOK(ecode2)) {
47971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47972 }
47973 arg2 = static_cast< int >(val2);
47974 {
47975 PyThreadState* __tstate = wxPyBeginAllowThreads();
47976 (arg1)->SetFlexibleDirection(arg2);
47977 wxPyEndAllowThreads(__tstate);
47978 if (PyErr_Occurred()) SWIG_fail;
47979 }
47980 resultobj = SWIG_Py_Void();
47981 return resultobj;
47982 fail:
47983 return NULL;
47984 }
47985
47986
47987 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47988 PyObject *resultobj = 0;
47989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47990 int result;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 PyObject *swig_obj[1] ;
47994
47995 if (!args) SWIG_fail;
47996 swig_obj[0] = args;
47997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48002 {
48003 PyThreadState* __tstate = wxPyBeginAllowThreads();
48004 result = (int)(arg1)->GetFlexibleDirection();
48005 wxPyEndAllowThreads(__tstate);
48006 if (PyErr_Occurred()) SWIG_fail;
48007 }
48008 resultobj = SWIG_From_int(static_cast< int >(result));
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48016 PyObject *resultobj = 0;
48017 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48018 wxFlexSizerGrowMode arg2 ;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 int val2 ;
48022 int ecode2 = 0 ;
48023 PyObject * obj0 = 0 ;
48024 PyObject * obj1 = 0 ;
48025 char * kwnames[] = {
48026 (char *) "self",(char *) "mode", NULL
48027 };
48028
48029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48031 if (!SWIG_IsOK(res1)) {
48032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48033 }
48034 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48035 ecode2 = SWIG_AsVal_int(obj1, &val2);
48036 if (!SWIG_IsOK(ecode2)) {
48037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48038 }
48039 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48040 {
48041 PyThreadState* __tstate = wxPyBeginAllowThreads();
48042 (arg1)->SetNonFlexibleGrowMode(arg2);
48043 wxPyEndAllowThreads(__tstate);
48044 if (PyErr_Occurred()) SWIG_fail;
48045 }
48046 resultobj = SWIG_Py_Void();
48047 return resultobj;
48048 fail:
48049 return NULL;
48050 }
48051
48052
48053 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48054 PyObject *resultobj = 0;
48055 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48056 wxFlexSizerGrowMode result;
48057 void *argp1 = 0 ;
48058 int res1 = 0 ;
48059 PyObject *swig_obj[1] ;
48060
48061 if (!args) SWIG_fail;
48062 swig_obj[0] = args;
48063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48064 if (!SWIG_IsOK(res1)) {
48065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48066 }
48067 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48068 {
48069 PyThreadState* __tstate = wxPyBeginAllowThreads();
48070 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48071 wxPyEndAllowThreads(__tstate);
48072 if (PyErr_Occurred()) SWIG_fail;
48073 }
48074 resultobj = SWIG_From_int(static_cast< int >(result));
48075 return resultobj;
48076 fail:
48077 return NULL;
48078 }
48079
48080
48081 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48082 PyObject *resultobj = 0;
48083 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48084 wxArrayInt *result = 0 ;
48085 void *argp1 = 0 ;
48086 int res1 = 0 ;
48087 PyObject *swig_obj[1] ;
48088
48089 if (!args) SWIG_fail;
48090 swig_obj[0] = args;
48091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48092 if (!SWIG_IsOK(res1)) {
48093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48094 }
48095 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48096 {
48097 PyThreadState* __tstate = wxPyBeginAllowThreads();
48098 {
48099 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48100 result = (wxArrayInt *) &_result_ref;
48101 }
48102 wxPyEndAllowThreads(__tstate);
48103 if (PyErr_Occurred()) SWIG_fail;
48104 }
48105 {
48106 resultobj = PyList_New(0);
48107 size_t idx;
48108 for (idx = 0; idx < result->GetCount(); idx += 1) {
48109 PyObject* val = PyInt_FromLong( result->Item(idx) );
48110 PyList_Append(resultobj, val);
48111 Py_DECREF(val);
48112 }
48113 }
48114 return resultobj;
48115 fail:
48116 return NULL;
48117 }
48118
48119
48120 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48121 PyObject *resultobj = 0;
48122 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48123 wxArrayInt *result = 0 ;
48124 void *argp1 = 0 ;
48125 int res1 = 0 ;
48126 PyObject *swig_obj[1] ;
48127
48128 if (!args) SWIG_fail;
48129 swig_obj[0] = args;
48130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48131 if (!SWIG_IsOK(res1)) {
48132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48133 }
48134 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48135 {
48136 PyThreadState* __tstate = wxPyBeginAllowThreads();
48137 {
48138 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48139 result = (wxArrayInt *) &_result_ref;
48140 }
48141 wxPyEndAllowThreads(__tstate);
48142 if (PyErr_Occurred()) SWIG_fail;
48143 }
48144 {
48145 resultobj = PyList_New(0);
48146 size_t idx;
48147 for (idx = 0; idx < result->GetCount(); idx += 1) {
48148 PyObject* val = PyInt_FromLong( result->Item(idx) );
48149 PyList_Append(resultobj, val);
48150 Py_DECREF(val);
48151 }
48152 }
48153 return resultobj;
48154 fail:
48155 return NULL;
48156 }
48157
48158
48159 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48160 PyObject *obj;
48161 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48162 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48163 return SWIG_Py_Void();
48164 }
48165
48166 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48167 return SWIG_Python_InitShadowInstance(args);
48168 }
48169
48170 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48171 PyObject *resultobj = 0;
48172 wxStdDialogButtonSizer *result = 0 ;
48173
48174 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48175 {
48176 PyThreadState* __tstate = wxPyBeginAllowThreads();
48177 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48178 wxPyEndAllowThreads(__tstate);
48179 if (PyErr_Occurred()) SWIG_fail;
48180 }
48181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48182 return resultobj;
48183 fail:
48184 return NULL;
48185 }
48186
48187
48188 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48189 PyObject *resultobj = 0;
48190 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48191 wxButton *arg2 = (wxButton *) 0 ;
48192 void *argp1 = 0 ;
48193 int res1 = 0 ;
48194 void *argp2 = 0 ;
48195 int res2 = 0 ;
48196 PyObject * obj0 = 0 ;
48197 PyObject * obj1 = 0 ;
48198 char * kwnames[] = {
48199 (char *) "self",(char *) "button", NULL
48200 };
48201
48202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48204 if (!SWIG_IsOK(res1)) {
48205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48206 }
48207 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48208 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48209 if (!SWIG_IsOK(res2)) {
48210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48211 }
48212 arg2 = reinterpret_cast< wxButton * >(argp2);
48213 {
48214 PyThreadState* __tstate = wxPyBeginAllowThreads();
48215 (arg1)->AddButton(arg2);
48216 wxPyEndAllowThreads(__tstate);
48217 if (PyErr_Occurred()) SWIG_fail;
48218 }
48219 resultobj = SWIG_Py_Void();
48220 return resultobj;
48221 fail:
48222 return NULL;
48223 }
48224
48225
48226 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48227 PyObject *resultobj = 0;
48228 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48229 void *argp1 = 0 ;
48230 int res1 = 0 ;
48231 PyObject *swig_obj[1] ;
48232
48233 if (!args) SWIG_fail;
48234 swig_obj[0] = args;
48235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48236 if (!SWIG_IsOK(res1)) {
48237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48238 }
48239 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48240 {
48241 PyThreadState* __tstate = wxPyBeginAllowThreads();
48242 (arg1)->Realize();
48243 wxPyEndAllowThreads(__tstate);
48244 if (PyErr_Occurred()) SWIG_fail;
48245 }
48246 resultobj = SWIG_Py_Void();
48247 return resultobj;
48248 fail:
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48254 PyObject *resultobj = 0;
48255 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48256 wxButton *arg2 = (wxButton *) 0 ;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 void *argp2 = 0 ;
48260 int res2 = 0 ;
48261 PyObject * obj0 = 0 ;
48262 PyObject * obj1 = 0 ;
48263 char * kwnames[] = {
48264 (char *) "self",(char *) "button", NULL
48265 };
48266
48267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48269 if (!SWIG_IsOK(res1)) {
48270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48271 }
48272 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48273 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48274 if (!SWIG_IsOK(res2)) {
48275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48276 }
48277 arg2 = reinterpret_cast< wxButton * >(argp2);
48278 {
48279 PyThreadState* __tstate = wxPyBeginAllowThreads();
48280 (arg1)->SetAffirmativeButton(arg2);
48281 wxPyEndAllowThreads(__tstate);
48282 if (PyErr_Occurred()) SWIG_fail;
48283 }
48284 resultobj = SWIG_Py_Void();
48285 return resultobj;
48286 fail:
48287 return NULL;
48288 }
48289
48290
48291 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48292 PyObject *resultobj = 0;
48293 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48294 wxButton *arg2 = (wxButton *) 0 ;
48295 void *argp1 = 0 ;
48296 int res1 = 0 ;
48297 void *argp2 = 0 ;
48298 int res2 = 0 ;
48299 PyObject * obj0 = 0 ;
48300 PyObject * obj1 = 0 ;
48301 char * kwnames[] = {
48302 (char *) "self",(char *) "button", NULL
48303 };
48304
48305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48307 if (!SWIG_IsOK(res1)) {
48308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48309 }
48310 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48312 if (!SWIG_IsOK(res2)) {
48313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48314 }
48315 arg2 = reinterpret_cast< wxButton * >(argp2);
48316 {
48317 PyThreadState* __tstate = wxPyBeginAllowThreads();
48318 (arg1)->SetNegativeButton(arg2);
48319 wxPyEndAllowThreads(__tstate);
48320 if (PyErr_Occurred()) SWIG_fail;
48321 }
48322 resultobj = SWIG_Py_Void();
48323 return resultobj;
48324 fail:
48325 return NULL;
48326 }
48327
48328
48329 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48330 PyObject *resultobj = 0;
48331 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48332 wxButton *arg2 = (wxButton *) 0 ;
48333 void *argp1 = 0 ;
48334 int res1 = 0 ;
48335 void *argp2 = 0 ;
48336 int res2 = 0 ;
48337 PyObject * obj0 = 0 ;
48338 PyObject * obj1 = 0 ;
48339 char * kwnames[] = {
48340 (char *) "self",(char *) "button", NULL
48341 };
48342
48343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48345 if (!SWIG_IsOK(res1)) {
48346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48347 }
48348 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48350 if (!SWIG_IsOK(res2)) {
48351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48352 }
48353 arg2 = reinterpret_cast< wxButton * >(argp2);
48354 {
48355 PyThreadState* __tstate = wxPyBeginAllowThreads();
48356 (arg1)->SetCancelButton(arg2);
48357 wxPyEndAllowThreads(__tstate);
48358 if (PyErr_Occurred()) SWIG_fail;
48359 }
48360 resultobj = SWIG_Py_Void();
48361 return resultobj;
48362 fail:
48363 return NULL;
48364 }
48365
48366
48367 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48368 PyObject *resultobj = 0;
48369 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48370 wxButton *result = 0 ;
48371 void *argp1 = 0 ;
48372 int res1 = 0 ;
48373 PyObject *swig_obj[1] ;
48374
48375 if (!args) SWIG_fail;
48376 swig_obj[0] = args;
48377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48378 if (!SWIG_IsOK(res1)) {
48379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48380 }
48381 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48382 {
48383 PyThreadState* __tstate = wxPyBeginAllowThreads();
48384 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48385 wxPyEndAllowThreads(__tstate);
48386 if (PyErr_Occurred()) SWIG_fail;
48387 }
48388 {
48389 resultobj = wxPyMake_wxObject(result, (bool)0);
48390 }
48391 return resultobj;
48392 fail:
48393 return NULL;
48394 }
48395
48396
48397 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48398 PyObject *resultobj = 0;
48399 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48400 wxButton *result = 0 ;
48401 void *argp1 = 0 ;
48402 int res1 = 0 ;
48403 PyObject *swig_obj[1] ;
48404
48405 if (!args) SWIG_fail;
48406 swig_obj[0] = args;
48407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48408 if (!SWIG_IsOK(res1)) {
48409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48410 }
48411 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48412 {
48413 PyThreadState* __tstate = wxPyBeginAllowThreads();
48414 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48415 wxPyEndAllowThreads(__tstate);
48416 if (PyErr_Occurred()) SWIG_fail;
48417 }
48418 {
48419 resultobj = wxPyMake_wxObject(result, (bool)0);
48420 }
48421 return resultobj;
48422 fail:
48423 return NULL;
48424 }
48425
48426
48427 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48428 PyObject *resultobj = 0;
48429 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48430 wxButton *result = 0 ;
48431 void *argp1 = 0 ;
48432 int res1 = 0 ;
48433 PyObject *swig_obj[1] ;
48434
48435 if (!args) SWIG_fail;
48436 swig_obj[0] = args;
48437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48438 if (!SWIG_IsOK(res1)) {
48439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48440 }
48441 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48442 {
48443 PyThreadState* __tstate = wxPyBeginAllowThreads();
48444 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48445 wxPyEndAllowThreads(__tstate);
48446 if (PyErr_Occurred()) SWIG_fail;
48447 }
48448 {
48449 resultobj = wxPyMake_wxObject(result, (bool)0);
48450 }
48451 return resultobj;
48452 fail:
48453 return NULL;
48454 }
48455
48456
48457 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48458 PyObject *resultobj = 0;
48459 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48460 wxButton *result = 0 ;
48461 void *argp1 = 0 ;
48462 int res1 = 0 ;
48463 PyObject *swig_obj[1] ;
48464
48465 if (!args) SWIG_fail;
48466 swig_obj[0] = args;
48467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48468 if (!SWIG_IsOK(res1)) {
48469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48470 }
48471 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48472 {
48473 PyThreadState* __tstate = wxPyBeginAllowThreads();
48474 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48475 wxPyEndAllowThreads(__tstate);
48476 if (PyErr_Occurred()) SWIG_fail;
48477 }
48478 {
48479 resultobj = wxPyMake_wxObject(result, (bool)0);
48480 }
48481 return resultobj;
48482 fail:
48483 return NULL;
48484 }
48485
48486
48487 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48488 PyObject *resultobj = 0;
48489 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48490 wxButton *result = 0 ;
48491 void *argp1 = 0 ;
48492 int res1 = 0 ;
48493 PyObject *swig_obj[1] ;
48494
48495 if (!args) SWIG_fail;
48496 swig_obj[0] = args;
48497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48498 if (!SWIG_IsOK(res1)) {
48499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48500 }
48501 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48502 {
48503 PyThreadState* __tstate = wxPyBeginAllowThreads();
48504 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48505 wxPyEndAllowThreads(__tstate);
48506 if (PyErr_Occurred()) SWIG_fail;
48507 }
48508 {
48509 resultobj = wxPyMake_wxObject(result, (bool)0);
48510 }
48511 return resultobj;
48512 fail:
48513 return NULL;
48514 }
48515
48516
48517 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48518 PyObject *obj;
48519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48520 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48521 return SWIG_Py_Void();
48522 }
48523
48524 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48525 return SWIG_Python_InitShadowInstance(args);
48526 }
48527
48528 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48529 PyObject *resultobj = 0;
48530 int arg1 = (int) 0 ;
48531 int arg2 = (int) 0 ;
48532 wxGBPosition *result = 0 ;
48533 int val1 ;
48534 int ecode1 = 0 ;
48535 int val2 ;
48536 int ecode2 = 0 ;
48537 PyObject * obj0 = 0 ;
48538 PyObject * obj1 = 0 ;
48539 char * kwnames[] = {
48540 (char *) "row",(char *) "col", NULL
48541 };
48542
48543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48544 if (obj0) {
48545 ecode1 = SWIG_AsVal_int(obj0, &val1);
48546 if (!SWIG_IsOK(ecode1)) {
48547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48548 }
48549 arg1 = static_cast< int >(val1);
48550 }
48551 if (obj1) {
48552 ecode2 = SWIG_AsVal_int(obj1, &val2);
48553 if (!SWIG_IsOK(ecode2)) {
48554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48555 }
48556 arg2 = static_cast< int >(val2);
48557 }
48558 {
48559 PyThreadState* __tstate = wxPyBeginAllowThreads();
48560 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48561 wxPyEndAllowThreads(__tstate);
48562 if (PyErr_Occurred()) SWIG_fail;
48563 }
48564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48565 return resultobj;
48566 fail:
48567 return NULL;
48568 }
48569
48570
48571 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48572 PyObject *resultobj = 0;
48573 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48574 void *argp1 = 0 ;
48575 int res1 = 0 ;
48576 PyObject *swig_obj[1] ;
48577
48578 if (!args) SWIG_fail;
48579 swig_obj[0] = args;
48580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48581 if (!SWIG_IsOK(res1)) {
48582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48583 }
48584 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48585 {
48586 PyThreadState* __tstate = wxPyBeginAllowThreads();
48587 delete arg1;
48588
48589 wxPyEndAllowThreads(__tstate);
48590 if (PyErr_Occurred()) SWIG_fail;
48591 }
48592 resultobj = SWIG_Py_Void();
48593 return resultobj;
48594 fail:
48595 return NULL;
48596 }
48597
48598
48599 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48600 PyObject *resultobj = 0;
48601 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48602 int result;
48603 void *argp1 = 0 ;
48604 int res1 = 0 ;
48605 PyObject *swig_obj[1] ;
48606
48607 if (!args) SWIG_fail;
48608 swig_obj[0] = args;
48609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48610 if (!SWIG_IsOK(res1)) {
48611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48612 }
48613 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48614 {
48615 PyThreadState* __tstate = wxPyBeginAllowThreads();
48616 result = (int)((wxGBPosition const *)arg1)->GetRow();
48617 wxPyEndAllowThreads(__tstate);
48618 if (PyErr_Occurred()) SWIG_fail;
48619 }
48620 resultobj = SWIG_From_int(static_cast< int >(result));
48621 return resultobj;
48622 fail:
48623 return NULL;
48624 }
48625
48626
48627 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48628 PyObject *resultobj = 0;
48629 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48630 int result;
48631 void *argp1 = 0 ;
48632 int res1 = 0 ;
48633 PyObject *swig_obj[1] ;
48634
48635 if (!args) SWIG_fail;
48636 swig_obj[0] = args;
48637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48638 if (!SWIG_IsOK(res1)) {
48639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48640 }
48641 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48642 {
48643 PyThreadState* __tstate = wxPyBeginAllowThreads();
48644 result = (int)((wxGBPosition const *)arg1)->GetCol();
48645 wxPyEndAllowThreads(__tstate);
48646 if (PyErr_Occurred()) SWIG_fail;
48647 }
48648 resultobj = SWIG_From_int(static_cast< int >(result));
48649 return resultobj;
48650 fail:
48651 return NULL;
48652 }
48653
48654
48655 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48656 PyObject *resultobj = 0;
48657 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48658 int arg2 ;
48659 void *argp1 = 0 ;
48660 int res1 = 0 ;
48661 int val2 ;
48662 int ecode2 = 0 ;
48663 PyObject * obj0 = 0 ;
48664 PyObject * obj1 = 0 ;
48665 char * kwnames[] = {
48666 (char *) "self",(char *) "row", NULL
48667 };
48668
48669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48673 }
48674 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48675 ecode2 = SWIG_AsVal_int(obj1, &val2);
48676 if (!SWIG_IsOK(ecode2)) {
48677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48678 }
48679 arg2 = static_cast< int >(val2);
48680 {
48681 PyThreadState* __tstate = wxPyBeginAllowThreads();
48682 (arg1)->SetRow(arg2);
48683 wxPyEndAllowThreads(__tstate);
48684 if (PyErr_Occurred()) SWIG_fail;
48685 }
48686 resultobj = SWIG_Py_Void();
48687 return resultobj;
48688 fail:
48689 return NULL;
48690 }
48691
48692
48693 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48694 PyObject *resultobj = 0;
48695 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48696 int arg2 ;
48697 void *argp1 = 0 ;
48698 int res1 = 0 ;
48699 int val2 ;
48700 int ecode2 = 0 ;
48701 PyObject * obj0 = 0 ;
48702 PyObject * obj1 = 0 ;
48703 char * kwnames[] = {
48704 (char *) "self",(char *) "col", NULL
48705 };
48706
48707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48709 if (!SWIG_IsOK(res1)) {
48710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48711 }
48712 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48713 ecode2 = SWIG_AsVal_int(obj1, &val2);
48714 if (!SWIG_IsOK(ecode2)) {
48715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48716 }
48717 arg2 = static_cast< int >(val2);
48718 {
48719 PyThreadState* __tstate = wxPyBeginAllowThreads();
48720 (arg1)->SetCol(arg2);
48721 wxPyEndAllowThreads(__tstate);
48722 if (PyErr_Occurred()) SWIG_fail;
48723 }
48724 resultobj = SWIG_Py_Void();
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48732 PyObject *resultobj = 0;
48733 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48734 PyObject *arg2 = (PyObject *) 0 ;
48735 bool result;
48736 void *argp1 = 0 ;
48737 int res1 = 0 ;
48738 PyObject * obj0 = 0 ;
48739 PyObject * obj1 = 0 ;
48740 char * kwnames[] = {
48741 (char *) "self",(char *) "other", NULL
48742 };
48743
48744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48746 if (!SWIG_IsOK(res1)) {
48747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48748 }
48749 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48750 arg2 = obj1;
48751 {
48752 result = (bool)wxGBPosition___eq__(arg1,arg2);
48753 if (PyErr_Occurred()) SWIG_fail;
48754 }
48755 {
48756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48757 }
48758 return resultobj;
48759 fail:
48760 return NULL;
48761 }
48762
48763
48764 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48765 PyObject *resultobj = 0;
48766 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48767 PyObject *arg2 = (PyObject *) 0 ;
48768 bool result;
48769 void *argp1 = 0 ;
48770 int res1 = 0 ;
48771 PyObject * obj0 = 0 ;
48772 PyObject * obj1 = 0 ;
48773 char * kwnames[] = {
48774 (char *) "self",(char *) "other", NULL
48775 };
48776
48777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48779 if (!SWIG_IsOK(res1)) {
48780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48781 }
48782 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48783 arg2 = obj1;
48784 {
48785 result = (bool)wxGBPosition___ne__(arg1,arg2);
48786 if (PyErr_Occurred()) SWIG_fail;
48787 }
48788 {
48789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48790 }
48791 return resultobj;
48792 fail:
48793 return NULL;
48794 }
48795
48796
48797 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48798 PyObject *resultobj = 0;
48799 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48800 int arg2 = (int) 0 ;
48801 int arg3 = (int) 0 ;
48802 void *argp1 = 0 ;
48803 int res1 = 0 ;
48804 int val2 ;
48805 int ecode2 = 0 ;
48806 int val3 ;
48807 int ecode3 = 0 ;
48808 PyObject * obj0 = 0 ;
48809 PyObject * obj1 = 0 ;
48810 PyObject * obj2 = 0 ;
48811 char * kwnames[] = {
48812 (char *) "self",(char *) "row",(char *) "col", NULL
48813 };
48814
48815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48817 if (!SWIG_IsOK(res1)) {
48818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48819 }
48820 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48821 if (obj1) {
48822 ecode2 = SWIG_AsVal_int(obj1, &val2);
48823 if (!SWIG_IsOK(ecode2)) {
48824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48825 }
48826 arg2 = static_cast< int >(val2);
48827 }
48828 if (obj2) {
48829 ecode3 = SWIG_AsVal_int(obj2, &val3);
48830 if (!SWIG_IsOK(ecode3)) {
48831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48832 }
48833 arg3 = static_cast< int >(val3);
48834 }
48835 {
48836 PyThreadState* __tstate = wxPyBeginAllowThreads();
48837 wxGBPosition_Set(arg1,arg2,arg3);
48838 wxPyEndAllowThreads(__tstate);
48839 if (PyErr_Occurred()) SWIG_fail;
48840 }
48841 resultobj = SWIG_Py_Void();
48842 return resultobj;
48843 fail:
48844 return NULL;
48845 }
48846
48847
48848 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48849 PyObject *resultobj = 0;
48850 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48851 PyObject *result = 0 ;
48852 void *argp1 = 0 ;
48853 int res1 = 0 ;
48854 PyObject *swig_obj[1] ;
48855
48856 if (!args) SWIG_fail;
48857 swig_obj[0] = args;
48858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48859 if (!SWIG_IsOK(res1)) {
48860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48861 }
48862 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48863 {
48864 PyThreadState* __tstate = wxPyBeginAllowThreads();
48865 result = (PyObject *)wxGBPosition_Get(arg1);
48866 wxPyEndAllowThreads(__tstate);
48867 if (PyErr_Occurred()) SWIG_fail;
48868 }
48869 resultobj = result;
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48877 PyObject *obj;
48878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48879 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48880 return SWIG_Py_Void();
48881 }
48882
48883 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48884 return SWIG_Python_InitShadowInstance(args);
48885 }
48886
48887 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48888 PyObject *resultobj = 0;
48889 int arg1 = (int) 1 ;
48890 int arg2 = (int) 1 ;
48891 wxGBSpan *result = 0 ;
48892 int val1 ;
48893 int ecode1 = 0 ;
48894 int val2 ;
48895 int ecode2 = 0 ;
48896 PyObject * obj0 = 0 ;
48897 PyObject * obj1 = 0 ;
48898 char * kwnames[] = {
48899 (char *) "rowspan",(char *) "colspan", NULL
48900 };
48901
48902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48903 if (obj0) {
48904 ecode1 = SWIG_AsVal_int(obj0, &val1);
48905 if (!SWIG_IsOK(ecode1)) {
48906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48907 }
48908 arg1 = static_cast< int >(val1);
48909 }
48910 if (obj1) {
48911 ecode2 = SWIG_AsVal_int(obj1, &val2);
48912 if (!SWIG_IsOK(ecode2)) {
48913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48914 }
48915 arg2 = static_cast< int >(val2);
48916 }
48917 {
48918 PyThreadState* __tstate = wxPyBeginAllowThreads();
48919 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48920 wxPyEndAllowThreads(__tstate);
48921 if (PyErr_Occurred()) SWIG_fail;
48922 }
48923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48924 return resultobj;
48925 fail:
48926 return NULL;
48927 }
48928
48929
48930 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48931 PyObject *resultobj = 0;
48932 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48933 void *argp1 = 0 ;
48934 int res1 = 0 ;
48935 PyObject *swig_obj[1] ;
48936
48937 if (!args) SWIG_fail;
48938 swig_obj[0] = args;
48939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48940 if (!SWIG_IsOK(res1)) {
48941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48942 }
48943 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48944 {
48945 PyThreadState* __tstate = wxPyBeginAllowThreads();
48946 delete arg1;
48947
48948 wxPyEndAllowThreads(__tstate);
48949 if (PyErr_Occurred()) SWIG_fail;
48950 }
48951 resultobj = SWIG_Py_Void();
48952 return resultobj;
48953 fail:
48954 return NULL;
48955 }
48956
48957
48958 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48959 PyObject *resultobj = 0;
48960 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48961 int result;
48962 void *argp1 = 0 ;
48963 int res1 = 0 ;
48964 PyObject *swig_obj[1] ;
48965
48966 if (!args) SWIG_fail;
48967 swig_obj[0] = args;
48968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48969 if (!SWIG_IsOK(res1)) {
48970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48971 }
48972 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48973 {
48974 PyThreadState* __tstate = wxPyBeginAllowThreads();
48975 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48976 wxPyEndAllowThreads(__tstate);
48977 if (PyErr_Occurred()) SWIG_fail;
48978 }
48979 resultobj = SWIG_From_int(static_cast< int >(result));
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 PyObject *resultobj = 0;
48988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48989 int result;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 PyObject *swig_obj[1] ;
48993
48994 if (!args) SWIG_fail;
48995 swig_obj[0] = args;
48996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48999 }
49000 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49001 {
49002 PyThreadState* __tstate = wxPyBeginAllowThreads();
49003 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49004 wxPyEndAllowThreads(__tstate);
49005 if (PyErr_Occurred()) SWIG_fail;
49006 }
49007 resultobj = SWIG_From_int(static_cast< int >(result));
49008 return resultobj;
49009 fail:
49010 return NULL;
49011 }
49012
49013
49014 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49015 PyObject *resultobj = 0;
49016 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49017 int arg2 ;
49018 void *argp1 = 0 ;
49019 int res1 = 0 ;
49020 int val2 ;
49021 int ecode2 = 0 ;
49022 PyObject * obj0 = 0 ;
49023 PyObject * obj1 = 0 ;
49024 char * kwnames[] = {
49025 (char *) "self",(char *) "rowspan", NULL
49026 };
49027
49028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49030 if (!SWIG_IsOK(res1)) {
49031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49032 }
49033 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49034 ecode2 = SWIG_AsVal_int(obj1, &val2);
49035 if (!SWIG_IsOK(ecode2)) {
49036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49037 }
49038 arg2 = static_cast< int >(val2);
49039 {
49040 PyThreadState* __tstate = wxPyBeginAllowThreads();
49041 (arg1)->SetRowspan(arg2);
49042 wxPyEndAllowThreads(__tstate);
49043 if (PyErr_Occurred()) SWIG_fail;
49044 }
49045 resultobj = SWIG_Py_Void();
49046 return resultobj;
49047 fail:
49048 return NULL;
49049 }
49050
49051
49052 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49053 PyObject *resultobj = 0;
49054 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49055 int arg2 ;
49056 void *argp1 = 0 ;
49057 int res1 = 0 ;
49058 int val2 ;
49059 int ecode2 = 0 ;
49060 PyObject * obj0 = 0 ;
49061 PyObject * obj1 = 0 ;
49062 char * kwnames[] = {
49063 (char *) "self",(char *) "colspan", NULL
49064 };
49065
49066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49068 if (!SWIG_IsOK(res1)) {
49069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49070 }
49071 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49072 ecode2 = SWIG_AsVal_int(obj1, &val2);
49073 if (!SWIG_IsOK(ecode2)) {
49074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49075 }
49076 arg2 = static_cast< int >(val2);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 (arg1)->SetColspan(arg2);
49080 wxPyEndAllowThreads(__tstate);
49081 if (PyErr_Occurred()) SWIG_fail;
49082 }
49083 resultobj = SWIG_Py_Void();
49084 return resultobj;
49085 fail:
49086 return NULL;
49087 }
49088
49089
49090 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49091 PyObject *resultobj = 0;
49092 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49093 PyObject *arg2 = (PyObject *) 0 ;
49094 bool result;
49095 void *argp1 = 0 ;
49096 int res1 = 0 ;
49097 PyObject * obj0 = 0 ;
49098 PyObject * obj1 = 0 ;
49099 char * kwnames[] = {
49100 (char *) "self",(char *) "other", NULL
49101 };
49102
49103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49105 if (!SWIG_IsOK(res1)) {
49106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49107 }
49108 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49109 arg2 = obj1;
49110 {
49111 result = (bool)wxGBSpan___eq__(arg1,arg2);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 {
49115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49116 }
49117 return resultobj;
49118 fail:
49119 return NULL;
49120 }
49121
49122
49123 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49124 PyObject *resultobj = 0;
49125 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49126 PyObject *arg2 = (PyObject *) 0 ;
49127 bool result;
49128 void *argp1 = 0 ;
49129 int res1 = 0 ;
49130 PyObject * obj0 = 0 ;
49131 PyObject * obj1 = 0 ;
49132 char * kwnames[] = {
49133 (char *) "self",(char *) "other", NULL
49134 };
49135
49136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49138 if (!SWIG_IsOK(res1)) {
49139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49140 }
49141 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49142 arg2 = obj1;
49143 {
49144 result = (bool)wxGBSpan___ne__(arg1,arg2);
49145 if (PyErr_Occurred()) SWIG_fail;
49146 }
49147 {
49148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49149 }
49150 return resultobj;
49151 fail:
49152 return NULL;
49153 }
49154
49155
49156 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49157 PyObject *resultobj = 0;
49158 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49159 int arg2 = (int) 1 ;
49160 int arg3 = (int) 1 ;
49161 void *argp1 = 0 ;
49162 int res1 = 0 ;
49163 int val2 ;
49164 int ecode2 = 0 ;
49165 int val3 ;
49166 int ecode3 = 0 ;
49167 PyObject * obj0 = 0 ;
49168 PyObject * obj1 = 0 ;
49169 PyObject * obj2 = 0 ;
49170 char * kwnames[] = {
49171 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49172 };
49173
49174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49176 if (!SWIG_IsOK(res1)) {
49177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49178 }
49179 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49180 if (obj1) {
49181 ecode2 = SWIG_AsVal_int(obj1, &val2);
49182 if (!SWIG_IsOK(ecode2)) {
49183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49184 }
49185 arg2 = static_cast< int >(val2);
49186 }
49187 if (obj2) {
49188 ecode3 = SWIG_AsVal_int(obj2, &val3);
49189 if (!SWIG_IsOK(ecode3)) {
49190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49191 }
49192 arg3 = static_cast< int >(val3);
49193 }
49194 {
49195 PyThreadState* __tstate = wxPyBeginAllowThreads();
49196 wxGBSpan_Set(arg1,arg2,arg3);
49197 wxPyEndAllowThreads(__tstate);
49198 if (PyErr_Occurred()) SWIG_fail;
49199 }
49200 resultobj = SWIG_Py_Void();
49201 return resultobj;
49202 fail:
49203 return NULL;
49204 }
49205
49206
49207 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49208 PyObject *resultobj = 0;
49209 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49210 PyObject *result = 0 ;
49211 void *argp1 = 0 ;
49212 int res1 = 0 ;
49213 PyObject *swig_obj[1] ;
49214
49215 if (!args) SWIG_fail;
49216 swig_obj[0] = args;
49217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49218 if (!SWIG_IsOK(res1)) {
49219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49220 }
49221 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49222 {
49223 PyThreadState* __tstate = wxPyBeginAllowThreads();
49224 result = (PyObject *)wxGBSpan_Get(arg1);
49225 wxPyEndAllowThreads(__tstate);
49226 if (PyErr_Occurred()) SWIG_fail;
49227 }
49228 resultobj = result;
49229 return resultobj;
49230 fail:
49231 return NULL;
49232 }
49233
49234
49235 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49236 PyObject *obj;
49237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49238 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49239 return SWIG_Py_Void();
49240 }
49241
49242 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49243 return SWIG_Python_InitShadowInstance(args);
49244 }
49245
49246 SWIGINTERN int DefaultSpan_set(PyObject *) {
49247 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49248 return 1;
49249 }
49250
49251
49252 SWIGINTERN PyObject *DefaultSpan_get(void) {
49253 PyObject *pyobj = 0;
49254
49255 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49256 return pyobj;
49257 }
49258
49259
49260 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49261 PyObject *resultobj = 0;
49262 wxGBSizerItem *result = 0 ;
49263
49264 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49265 {
49266 PyThreadState* __tstate = wxPyBeginAllowThreads();
49267 result = (wxGBSizerItem *)new wxGBSizerItem();
49268 wxPyEndAllowThreads(__tstate);
49269 if (PyErr_Occurred()) SWIG_fail;
49270 }
49271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49272 return resultobj;
49273 fail:
49274 return NULL;
49275 }
49276
49277
49278 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49279 PyObject *resultobj = 0;
49280 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49281 void *argp1 = 0 ;
49282 int res1 = 0 ;
49283 PyObject *swig_obj[1] ;
49284
49285 if (!args) SWIG_fail;
49286 swig_obj[0] = args;
49287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49288 if (!SWIG_IsOK(res1)) {
49289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49290 }
49291 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49292 {
49293 PyThreadState* __tstate = wxPyBeginAllowThreads();
49294 delete arg1;
49295
49296 wxPyEndAllowThreads(__tstate);
49297 if (PyErr_Occurred()) SWIG_fail;
49298 }
49299 resultobj = SWIG_Py_Void();
49300 return resultobj;
49301 fail:
49302 return NULL;
49303 }
49304
49305
49306 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49307 PyObject *resultobj = 0;
49308 wxWindow *arg1 = (wxWindow *) 0 ;
49309 wxGBPosition *arg2 = 0 ;
49310 wxGBSpan *arg3 = 0 ;
49311 int arg4 ;
49312 int arg5 ;
49313 PyObject *arg6 = (PyObject *) NULL ;
49314 wxGBSizerItem *result = 0 ;
49315 void *argp1 = 0 ;
49316 int res1 = 0 ;
49317 wxGBPosition temp2 ;
49318 wxGBSpan temp3 ;
49319 int val4 ;
49320 int ecode4 = 0 ;
49321 int val5 ;
49322 int ecode5 = 0 ;
49323 PyObject * obj0 = 0 ;
49324 PyObject * obj1 = 0 ;
49325 PyObject * obj2 = 0 ;
49326 PyObject * obj3 = 0 ;
49327 PyObject * obj4 = 0 ;
49328 PyObject * obj5 = 0 ;
49329 char * kwnames[] = {
49330 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49331 };
49332
49333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49335 if (!SWIG_IsOK(res1)) {
49336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49337 }
49338 arg1 = reinterpret_cast< wxWindow * >(argp1);
49339 {
49340 arg2 = &temp2;
49341 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49342 }
49343 {
49344 arg3 = &temp3;
49345 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49346 }
49347 ecode4 = SWIG_AsVal_int(obj3, &val4);
49348 if (!SWIG_IsOK(ecode4)) {
49349 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49350 }
49351 arg4 = static_cast< int >(val4);
49352 ecode5 = SWIG_AsVal_int(obj4, &val5);
49353 if (!SWIG_IsOK(ecode5)) {
49354 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49355 }
49356 arg5 = static_cast< int >(val5);
49357 if (obj5) {
49358 arg6 = obj5;
49359 }
49360 {
49361 PyThreadState* __tstate = wxPyBeginAllowThreads();
49362 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49363 wxPyEndAllowThreads(__tstate);
49364 if (PyErr_Occurred()) SWIG_fail;
49365 }
49366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49367 return resultobj;
49368 fail:
49369 return NULL;
49370 }
49371
49372
49373 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49374 PyObject *resultobj = 0;
49375 wxSizer *arg1 = (wxSizer *) 0 ;
49376 wxGBPosition *arg2 = 0 ;
49377 wxGBSpan *arg3 = 0 ;
49378 int arg4 ;
49379 int arg5 ;
49380 PyObject *arg6 = (PyObject *) NULL ;
49381 wxGBSizerItem *result = 0 ;
49382 int res1 = 0 ;
49383 wxGBPosition temp2 ;
49384 wxGBSpan temp3 ;
49385 int val4 ;
49386 int ecode4 = 0 ;
49387 int val5 ;
49388 int ecode5 = 0 ;
49389 PyObject * obj0 = 0 ;
49390 PyObject * obj1 = 0 ;
49391 PyObject * obj2 = 0 ;
49392 PyObject * obj3 = 0 ;
49393 PyObject * obj4 = 0 ;
49394 PyObject * obj5 = 0 ;
49395 char * kwnames[] = {
49396 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49397 };
49398
49399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49400 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49401 if (!SWIG_IsOK(res1)) {
49402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49403 }
49404 {
49405 arg2 = &temp2;
49406 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49407 }
49408 {
49409 arg3 = &temp3;
49410 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49411 }
49412 ecode4 = SWIG_AsVal_int(obj3, &val4);
49413 if (!SWIG_IsOK(ecode4)) {
49414 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49415 }
49416 arg4 = static_cast< int >(val4);
49417 ecode5 = SWIG_AsVal_int(obj4, &val5);
49418 if (!SWIG_IsOK(ecode5)) {
49419 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49420 }
49421 arg5 = static_cast< int >(val5);
49422 if (obj5) {
49423 arg6 = obj5;
49424 }
49425 {
49426 PyThreadState* __tstate = wxPyBeginAllowThreads();
49427 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49428 wxPyEndAllowThreads(__tstate);
49429 if (PyErr_Occurred()) SWIG_fail;
49430 }
49431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49432 return resultobj;
49433 fail:
49434 return NULL;
49435 }
49436
49437
49438 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49439 PyObject *resultobj = 0;
49440 int arg1 ;
49441 int arg2 ;
49442 wxGBPosition *arg3 = 0 ;
49443 wxGBSpan *arg4 = 0 ;
49444 int arg5 ;
49445 int arg6 ;
49446 PyObject *arg7 = (PyObject *) NULL ;
49447 wxGBSizerItem *result = 0 ;
49448 int val1 ;
49449 int ecode1 = 0 ;
49450 int val2 ;
49451 int ecode2 = 0 ;
49452 wxGBPosition temp3 ;
49453 wxGBSpan temp4 ;
49454 int val5 ;
49455 int ecode5 = 0 ;
49456 int val6 ;
49457 int ecode6 = 0 ;
49458 PyObject * obj0 = 0 ;
49459 PyObject * obj1 = 0 ;
49460 PyObject * obj2 = 0 ;
49461 PyObject * obj3 = 0 ;
49462 PyObject * obj4 = 0 ;
49463 PyObject * obj5 = 0 ;
49464 PyObject * obj6 = 0 ;
49465 char * kwnames[] = {
49466 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49467 };
49468
49469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49470 ecode1 = SWIG_AsVal_int(obj0, &val1);
49471 if (!SWIG_IsOK(ecode1)) {
49472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49473 }
49474 arg1 = static_cast< int >(val1);
49475 ecode2 = SWIG_AsVal_int(obj1, &val2);
49476 if (!SWIG_IsOK(ecode2)) {
49477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49478 }
49479 arg2 = static_cast< int >(val2);
49480 {
49481 arg3 = &temp3;
49482 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49483 }
49484 {
49485 arg4 = &temp4;
49486 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49487 }
49488 ecode5 = SWIG_AsVal_int(obj4, &val5);
49489 if (!SWIG_IsOK(ecode5)) {
49490 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49491 }
49492 arg5 = static_cast< int >(val5);
49493 ecode6 = SWIG_AsVal_int(obj5, &val6);
49494 if (!SWIG_IsOK(ecode6)) {
49495 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49496 }
49497 arg6 = static_cast< int >(val6);
49498 if (obj6) {
49499 arg7 = obj6;
49500 }
49501 {
49502 PyThreadState* __tstate = wxPyBeginAllowThreads();
49503 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49504 wxPyEndAllowThreads(__tstate);
49505 if (PyErr_Occurred()) SWIG_fail;
49506 }
49507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49508 return resultobj;
49509 fail:
49510 return NULL;
49511 }
49512
49513
49514 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49515 PyObject *resultobj = 0;
49516 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49517 wxGBPosition result;
49518 void *argp1 = 0 ;
49519 int res1 = 0 ;
49520 PyObject *swig_obj[1] ;
49521
49522 if (!args) SWIG_fail;
49523 swig_obj[0] = args;
49524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49525 if (!SWIG_IsOK(res1)) {
49526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49527 }
49528 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49529 {
49530 PyThreadState* __tstate = wxPyBeginAllowThreads();
49531 result = ((wxGBSizerItem const *)arg1)->GetPos();
49532 wxPyEndAllowThreads(__tstate);
49533 if (PyErr_Occurred()) SWIG_fail;
49534 }
49535 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49536 return resultobj;
49537 fail:
49538 return NULL;
49539 }
49540
49541
49542 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49543 PyObject *resultobj = 0;
49544 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49545 wxGBSpan result;
49546 void *argp1 = 0 ;
49547 int res1 = 0 ;
49548 PyObject *swig_obj[1] ;
49549
49550 if (!args) SWIG_fail;
49551 swig_obj[0] = args;
49552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49553 if (!SWIG_IsOK(res1)) {
49554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49555 }
49556 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49571 PyObject *resultobj = 0;
49572 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49573 wxGBPosition *arg2 = 0 ;
49574 bool result;
49575 void *argp1 = 0 ;
49576 int res1 = 0 ;
49577 wxGBPosition temp2 ;
49578 PyObject * obj0 = 0 ;
49579 PyObject * obj1 = 0 ;
49580 char * kwnames[] = {
49581 (char *) "self",(char *) "pos", NULL
49582 };
49583
49584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49586 if (!SWIG_IsOK(res1)) {
49587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49588 }
49589 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49590 {
49591 arg2 = &temp2;
49592 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49593 }
49594 {
49595 PyThreadState* __tstate = wxPyBeginAllowThreads();
49596 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49597 wxPyEndAllowThreads(__tstate);
49598 if (PyErr_Occurred()) SWIG_fail;
49599 }
49600 {
49601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49602 }
49603 return resultobj;
49604 fail:
49605 return NULL;
49606 }
49607
49608
49609 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49610 PyObject *resultobj = 0;
49611 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49612 wxGBSpan *arg2 = 0 ;
49613 bool result;
49614 void *argp1 = 0 ;
49615 int res1 = 0 ;
49616 wxGBSpan temp2 ;
49617 PyObject * obj0 = 0 ;
49618 PyObject * obj1 = 0 ;
49619 char * kwnames[] = {
49620 (char *) "self",(char *) "span", NULL
49621 };
49622
49623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49625 if (!SWIG_IsOK(res1)) {
49626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49627 }
49628 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49629 {
49630 arg2 = &temp2;
49631 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49632 }
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 {
49640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49641 }
49642 return resultobj;
49643 fail:
49644 return NULL;
49645 }
49646
49647
49648 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49649 PyObject *resultobj = 0;
49650 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49651 wxGBSizerItem *arg2 = 0 ;
49652 bool result;
49653 void *argp1 = 0 ;
49654 int res1 = 0 ;
49655 void *argp2 = 0 ;
49656 int res2 = 0 ;
49657 PyObject * obj0 = 0 ;
49658 PyObject * obj1 = 0 ;
49659 char * kwnames[] = {
49660 (char *) "self",(char *) "other", NULL
49661 };
49662
49663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49665 if (!SWIG_IsOK(res1)) {
49666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49667 }
49668 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49669 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49670 if (!SWIG_IsOK(res2)) {
49671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49672 }
49673 if (!argp2) {
49674 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49675 }
49676 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49677 {
49678 PyThreadState* __tstate = wxPyBeginAllowThreads();
49679 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49680 wxPyEndAllowThreads(__tstate);
49681 if (PyErr_Occurred()) SWIG_fail;
49682 }
49683 {
49684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49685 }
49686 return resultobj;
49687 fail:
49688 return NULL;
49689 }
49690
49691
49692 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49693 PyObject *resultobj = 0;
49694 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49695 wxGBPosition *arg2 = 0 ;
49696 wxGBSpan *arg3 = 0 ;
49697 bool result;
49698 void *argp1 = 0 ;
49699 int res1 = 0 ;
49700 wxGBPosition temp2 ;
49701 wxGBSpan temp3 ;
49702 PyObject * obj0 = 0 ;
49703 PyObject * obj1 = 0 ;
49704 PyObject * obj2 = 0 ;
49705 char * kwnames[] = {
49706 (char *) "self",(char *) "pos",(char *) "span", NULL
49707 };
49708
49709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49711 if (!SWIG_IsOK(res1)) {
49712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49713 }
49714 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49715 {
49716 arg2 = &temp2;
49717 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49718 }
49719 {
49720 arg3 = &temp3;
49721 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49722 }
49723 {
49724 PyThreadState* __tstate = wxPyBeginAllowThreads();
49725 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49726 wxPyEndAllowThreads(__tstate);
49727 if (PyErr_Occurred()) SWIG_fail;
49728 }
49729 {
49730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49731 }
49732 return resultobj;
49733 fail:
49734 return NULL;
49735 }
49736
49737
49738 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49739 PyObject *resultobj = 0;
49740 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49741 wxGBPosition result;
49742 void *argp1 = 0 ;
49743 int res1 = 0 ;
49744 PyObject *swig_obj[1] ;
49745
49746 if (!args) SWIG_fail;
49747 swig_obj[0] = args;
49748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49749 if (!SWIG_IsOK(res1)) {
49750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49751 }
49752 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 result = wxGBSizerItem_GetEndPos(arg1);
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49767 PyObject *resultobj = 0;
49768 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49769 wxGridBagSizer *result = 0 ;
49770 void *argp1 = 0 ;
49771 int res1 = 0 ;
49772 PyObject *swig_obj[1] ;
49773
49774 if (!args) SWIG_fail;
49775 swig_obj[0] = args;
49776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49777 if (!SWIG_IsOK(res1)) {
49778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49779 }
49780 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49795 PyObject *resultobj = 0;
49796 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49797 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49798 void *argp1 = 0 ;
49799 int res1 = 0 ;
49800 void *argp2 = 0 ;
49801 int res2 = 0 ;
49802 PyObject * obj0 = 0 ;
49803 PyObject * obj1 = 0 ;
49804 char * kwnames[] = {
49805 (char *) "self",(char *) "sizer", NULL
49806 };
49807
49808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49810 if (!SWIG_IsOK(res1)) {
49811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49812 }
49813 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49814 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49815 if (!SWIG_IsOK(res2)) {
49816 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49817 }
49818 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49819 {
49820 PyThreadState* __tstate = wxPyBeginAllowThreads();
49821 (arg1)->SetGBSizer(arg2);
49822 wxPyEndAllowThreads(__tstate);
49823 if (PyErr_Occurred()) SWIG_fail;
49824 }
49825 resultobj = SWIG_Py_Void();
49826 return resultobj;
49827 fail:
49828 return NULL;
49829 }
49830
49831
49832 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49833 PyObject *obj;
49834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49835 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49836 return SWIG_Py_Void();
49837 }
49838
49839 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49840 return SWIG_Python_InitShadowInstance(args);
49841 }
49842
49843 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49844 PyObject *resultobj = 0;
49845 int arg1 = (int) 0 ;
49846 int arg2 = (int) 0 ;
49847 wxGridBagSizer *result = 0 ;
49848 int val1 ;
49849 int ecode1 = 0 ;
49850 int val2 ;
49851 int ecode2 = 0 ;
49852 PyObject * obj0 = 0 ;
49853 PyObject * obj1 = 0 ;
49854 char * kwnames[] = {
49855 (char *) "vgap",(char *) "hgap", NULL
49856 };
49857
49858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49859 if (obj0) {
49860 ecode1 = SWIG_AsVal_int(obj0, &val1);
49861 if (!SWIG_IsOK(ecode1)) {
49862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49863 }
49864 arg1 = static_cast< int >(val1);
49865 }
49866 if (obj1) {
49867 ecode2 = SWIG_AsVal_int(obj1, &val2);
49868 if (!SWIG_IsOK(ecode2)) {
49869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49870 }
49871 arg2 = static_cast< int >(val2);
49872 }
49873 {
49874 PyThreadState* __tstate = wxPyBeginAllowThreads();
49875 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49876 wxPyEndAllowThreads(__tstate);
49877 if (PyErr_Occurred()) SWIG_fail;
49878 }
49879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49880 return resultobj;
49881 fail:
49882 return NULL;
49883 }
49884
49885
49886 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49887 PyObject *resultobj = 0;
49888 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49889 PyObject *arg2 = (PyObject *) 0 ;
49890 wxGBPosition *arg3 = 0 ;
49891 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49892 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49893 int arg5 = (int) 0 ;
49894 int arg6 = (int) 0 ;
49895 PyObject *arg7 = (PyObject *) NULL ;
49896 wxGBSizerItem *result = 0 ;
49897 void *argp1 = 0 ;
49898 int res1 = 0 ;
49899 wxGBPosition temp3 ;
49900 wxGBSpan temp4 ;
49901 int val5 ;
49902 int ecode5 = 0 ;
49903 int val6 ;
49904 int ecode6 = 0 ;
49905 PyObject * obj0 = 0 ;
49906 PyObject * obj1 = 0 ;
49907 PyObject * obj2 = 0 ;
49908 PyObject * obj3 = 0 ;
49909 PyObject * obj4 = 0 ;
49910 PyObject * obj5 = 0 ;
49911 PyObject * obj6 = 0 ;
49912 char * kwnames[] = {
49913 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49914 };
49915
49916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49918 if (!SWIG_IsOK(res1)) {
49919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49920 }
49921 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49922 arg2 = obj1;
49923 {
49924 arg3 = &temp3;
49925 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49926 }
49927 if (obj3) {
49928 {
49929 arg4 = &temp4;
49930 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49931 }
49932 }
49933 if (obj4) {
49934 ecode5 = SWIG_AsVal_int(obj4, &val5);
49935 if (!SWIG_IsOK(ecode5)) {
49936 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49937 }
49938 arg5 = static_cast< int >(val5);
49939 }
49940 if (obj5) {
49941 ecode6 = SWIG_AsVal_int(obj5, &val6);
49942 if (!SWIG_IsOK(ecode6)) {
49943 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49944 }
49945 arg6 = static_cast< int >(val6);
49946 }
49947 if (obj6) {
49948 arg7 = obj6;
49949 }
49950 {
49951 PyThreadState* __tstate = wxPyBeginAllowThreads();
49952 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49953 wxPyEndAllowThreads(__tstate);
49954 if (PyErr_Occurred()) SWIG_fail;
49955 }
49956 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49957 return resultobj;
49958 fail:
49959 return NULL;
49960 }
49961
49962
49963 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49964 PyObject *resultobj = 0;
49965 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49966 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49967 wxGBSizerItem *result = 0 ;
49968 void *argp1 = 0 ;
49969 int res1 = 0 ;
49970 int res2 = 0 ;
49971 PyObject * obj0 = 0 ;
49972 PyObject * obj1 = 0 ;
49973 char * kwnames[] = {
49974 (char *) "self",(char *) "item", NULL
49975 };
49976
49977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49979 if (!SWIG_IsOK(res1)) {
49980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49981 }
49982 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49983 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49984 if (!SWIG_IsOK(res2)) {
49985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49986 }
49987 {
49988 PyThreadState* __tstate = wxPyBeginAllowThreads();
49989 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49990 wxPyEndAllowThreads(__tstate);
49991 if (PyErr_Occurred()) SWIG_fail;
49992 }
49993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49994 return resultobj;
49995 fail:
49996 return NULL;
49997 }
49998
49999
50000 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50001 PyObject *resultobj = 0;
50002 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50003 int arg2 ;
50004 int arg3 ;
50005 wxSize result;
50006 void *argp1 = 0 ;
50007 int res1 = 0 ;
50008 int val2 ;
50009 int ecode2 = 0 ;
50010 int val3 ;
50011 int ecode3 = 0 ;
50012 PyObject * obj0 = 0 ;
50013 PyObject * obj1 = 0 ;
50014 PyObject * obj2 = 0 ;
50015 char * kwnames[] = {
50016 (char *) "self",(char *) "row",(char *) "col", NULL
50017 };
50018
50019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50021 if (!SWIG_IsOK(res1)) {
50022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50023 }
50024 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50025 ecode2 = SWIG_AsVal_int(obj1, &val2);
50026 if (!SWIG_IsOK(ecode2)) {
50027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50028 }
50029 arg2 = static_cast< int >(val2);
50030 ecode3 = SWIG_AsVal_int(obj2, &val3);
50031 if (!SWIG_IsOK(ecode3)) {
50032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50033 }
50034 arg3 = static_cast< int >(val3);
50035 {
50036 PyThreadState* __tstate = wxPyBeginAllowThreads();
50037 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50038 wxPyEndAllowThreads(__tstate);
50039 if (PyErr_Occurred()) SWIG_fail;
50040 }
50041 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50042 return resultobj;
50043 fail:
50044 return NULL;
50045 }
50046
50047
50048 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50049 PyObject *resultobj = 0;
50050 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50051 wxSize result;
50052 void *argp1 = 0 ;
50053 int res1 = 0 ;
50054 PyObject *swig_obj[1] ;
50055
50056 if (!args) SWIG_fail;
50057 swig_obj[0] = args;
50058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50059 if (!SWIG_IsOK(res1)) {
50060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50061 }
50062 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50063 {
50064 PyThreadState* __tstate = wxPyBeginAllowThreads();
50065 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50066 wxPyEndAllowThreads(__tstate);
50067 if (PyErr_Occurred()) SWIG_fail;
50068 }
50069 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50079 wxSize *arg2 = 0 ;
50080 void *argp1 = 0 ;
50081 int res1 = 0 ;
50082 wxSize temp2 ;
50083 PyObject * obj0 = 0 ;
50084 PyObject * obj1 = 0 ;
50085 char * kwnames[] = {
50086 (char *) "self",(char *) "sz", NULL
50087 };
50088
50089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50091 if (!SWIG_IsOK(res1)) {
50092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50093 }
50094 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50095 {
50096 arg2 = &temp2;
50097 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50098 }
50099 {
50100 PyThreadState* __tstate = wxPyBeginAllowThreads();
50101 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50102 wxPyEndAllowThreads(__tstate);
50103 if (PyErr_Occurred()) SWIG_fail;
50104 }
50105 resultobj = SWIG_Py_Void();
50106 return resultobj;
50107 fail:
50108 return NULL;
50109 }
50110
50111
50112 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50113 PyObject *resultobj = 0;
50114 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50115 wxWindow *arg2 = (wxWindow *) 0 ;
50116 wxGBPosition result;
50117 void *argp1 = 0 ;
50118 int res1 = 0 ;
50119 void *argp2 = 0 ;
50120 int res2 = 0 ;
50121
50122 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50124 if (!SWIG_IsOK(res1)) {
50125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50126 }
50127 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50128 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50129 if (!SWIG_IsOK(res2)) {
50130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50131 }
50132 arg2 = reinterpret_cast< wxWindow * >(argp2);
50133 {
50134 PyThreadState* __tstate = wxPyBeginAllowThreads();
50135 result = (arg1)->GetItemPosition(arg2);
50136 wxPyEndAllowThreads(__tstate);
50137 if (PyErr_Occurred()) SWIG_fail;
50138 }
50139 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50140 return resultobj;
50141 fail:
50142 return NULL;
50143 }
50144
50145
50146 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50147 PyObject *resultobj = 0;
50148 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50149 wxSizer *arg2 = (wxSizer *) 0 ;
50150 wxGBPosition result;
50151 void *argp1 = 0 ;
50152 int res1 = 0 ;
50153 void *argp2 = 0 ;
50154 int res2 = 0 ;
50155
50156 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50158 if (!SWIG_IsOK(res1)) {
50159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50160 }
50161 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50162 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50163 if (!SWIG_IsOK(res2)) {
50164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50165 }
50166 arg2 = reinterpret_cast< wxSizer * >(argp2);
50167 {
50168 PyThreadState* __tstate = wxPyBeginAllowThreads();
50169 result = (arg1)->GetItemPosition(arg2);
50170 wxPyEndAllowThreads(__tstate);
50171 if (PyErr_Occurred()) SWIG_fail;
50172 }
50173 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50174 return resultobj;
50175 fail:
50176 return NULL;
50177 }
50178
50179
50180 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50181 PyObject *resultobj = 0;
50182 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50183 size_t arg2 ;
50184 wxGBPosition result;
50185 void *argp1 = 0 ;
50186 int res1 = 0 ;
50187 size_t val2 ;
50188 int ecode2 = 0 ;
50189
50190 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50192 if (!SWIG_IsOK(res1)) {
50193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50194 }
50195 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50196 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50197 if (!SWIG_IsOK(ecode2)) {
50198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50199 }
50200 arg2 = static_cast< size_t >(val2);
50201 {
50202 PyThreadState* __tstate = wxPyBeginAllowThreads();
50203 result = (arg1)->GetItemPosition(arg2);
50204 wxPyEndAllowThreads(__tstate);
50205 if (PyErr_Occurred()) SWIG_fail;
50206 }
50207 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50208 return resultobj;
50209 fail:
50210 return NULL;
50211 }
50212
50213
50214 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50215 int argc;
50216 PyObject *argv[3];
50217
50218 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50219 --argc;
50220 if (argc == 2) {
50221 int _v = 0;
50222 {
50223 void *vptr = 0;
50224 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50225 _v = SWIG_CheckState(res);
50226 }
50227 if (!_v) goto check_1;
50228 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50229 }
50230 check_1:
50231
50232 if (argc == 2) {
50233 int _v = 0;
50234 {
50235 void *vptr = 0;
50236 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50237 _v = SWIG_CheckState(res);
50238 }
50239 if (!_v) goto check_2;
50240 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50241 }
50242 check_2:
50243
50244 if (argc == 2) {
50245 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50246 }
50247
50248 fail:
50249 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50250 return NULL;
50251 }
50252
50253
50254 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50255 PyObject *resultobj = 0;
50256 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50257 wxWindow *arg2 = (wxWindow *) 0 ;
50258 wxGBPosition *arg3 = 0 ;
50259 bool result;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 void *argp2 = 0 ;
50263 int res2 = 0 ;
50264 wxGBPosition temp3 ;
50265
50266 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50270 }
50271 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50272 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50273 if (!SWIG_IsOK(res2)) {
50274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50275 }
50276 arg2 = reinterpret_cast< wxWindow * >(argp2);
50277 {
50278 arg3 = &temp3;
50279 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50280 }
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 {
50288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50289 }
50290 return resultobj;
50291 fail:
50292 return NULL;
50293 }
50294
50295
50296 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50297 PyObject *resultobj = 0;
50298 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50299 wxSizer *arg2 = (wxSizer *) 0 ;
50300 wxGBPosition *arg3 = 0 ;
50301 bool result;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 void *argp2 = 0 ;
50305 int res2 = 0 ;
50306 wxGBPosition temp3 ;
50307
50308 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50310 if (!SWIG_IsOK(res1)) {
50311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50312 }
50313 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50314 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50315 if (!SWIG_IsOK(res2)) {
50316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50317 }
50318 arg2 = reinterpret_cast< wxSizer * >(argp2);
50319 {
50320 arg3 = &temp3;
50321 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50322 }
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 {
50330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50331 }
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50339 PyObject *resultobj = 0;
50340 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50341 size_t arg2 ;
50342 wxGBPosition *arg3 = 0 ;
50343 bool result;
50344 void *argp1 = 0 ;
50345 int res1 = 0 ;
50346 size_t val2 ;
50347 int ecode2 = 0 ;
50348 wxGBPosition temp3 ;
50349
50350 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50352 if (!SWIG_IsOK(res1)) {
50353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50354 }
50355 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50356 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50357 if (!SWIG_IsOK(ecode2)) {
50358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50359 }
50360 arg2 = static_cast< size_t >(val2);
50361 {
50362 arg3 = &temp3;
50363 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50364 }
50365 {
50366 PyThreadState* __tstate = wxPyBeginAllowThreads();
50367 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50368 wxPyEndAllowThreads(__tstate);
50369 if (PyErr_Occurred()) SWIG_fail;
50370 }
50371 {
50372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50373 }
50374 return resultobj;
50375 fail:
50376 return NULL;
50377 }
50378
50379
50380 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50381 int argc;
50382 PyObject *argv[4];
50383
50384 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50385 --argc;
50386 if (argc == 3) {
50387 int _v = 0;
50388 {
50389 void *vptr = 0;
50390 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50391 _v = SWIG_CheckState(res);
50392 }
50393 if (!_v) goto check_1;
50394 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50395 }
50396 check_1:
50397
50398 if (argc == 3) {
50399 int _v = 0;
50400 {
50401 void *vptr = 0;
50402 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50403 _v = SWIG_CheckState(res);
50404 }
50405 if (!_v) goto check_2;
50406 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50407 }
50408 check_2:
50409
50410 if (argc == 3) {
50411 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50412 }
50413
50414 fail:
50415 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50416 return NULL;
50417 }
50418
50419
50420 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50421 PyObject *resultobj = 0;
50422 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50423 wxWindow *arg2 = (wxWindow *) 0 ;
50424 wxGBSpan result;
50425 void *argp1 = 0 ;
50426 int res1 = 0 ;
50427 void *argp2 = 0 ;
50428 int res2 = 0 ;
50429
50430 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50432 if (!SWIG_IsOK(res1)) {
50433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50434 }
50435 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50436 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50437 if (!SWIG_IsOK(res2)) {
50438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50439 }
50440 arg2 = reinterpret_cast< wxWindow * >(argp2);
50441 {
50442 PyThreadState* __tstate = wxPyBeginAllowThreads();
50443 result = (arg1)->GetItemSpan(arg2);
50444 wxPyEndAllowThreads(__tstate);
50445 if (PyErr_Occurred()) SWIG_fail;
50446 }
50447 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50448 return resultobj;
50449 fail:
50450 return NULL;
50451 }
50452
50453
50454 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50455 PyObject *resultobj = 0;
50456 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50457 wxSizer *arg2 = (wxSizer *) 0 ;
50458 wxGBSpan result;
50459 void *argp1 = 0 ;
50460 int res1 = 0 ;
50461 void *argp2 = 0 ;
50462 int res2 = 0 ;
50463
50464 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50466 if (!SWIG_IsOK(res1)) {
50467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50468 }
50469 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50470 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50471 if (!SWIG_IsOK(res2)) {
50472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50473 }
50474 arg2 = reinterpret_cast< wxSizer * >(argp2);
50475 {
50476 PyThreadState* __tstate = wxPyBeginAllowThreads();
50477 result = (arg1)->GetItemSpan(arg2);
50478 wxPyEndAllowThreads(__tstate);
50479 if (PyErr_Occurred()) SWIG_fail;
50480 }
50481 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50489 PyObject *resultobj = 0;
50490 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50491 size_t arg2 ;
50492 wxGBSpan result;
50493 void *argp1 = 0 ;
50494 int res1 = 0 ;
50495 size_t val2 ;
50496 int ecode2 = 0 ;
50497
50498 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50500 if (!SWIG_IsOK(res1)) {
50501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50502 }
50503 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50504 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50505 if (!SWIG_IsOK(ecode2)) {
50506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50507 }
50508 arg2 = static_cast< size_t >(val2);
50509 {
50510 PyThreadState* __tstate = wxPyBeginAllowThreads();
50511 result = (arg1)->GetItemSpan(arg2);
50512 wxPyEndAllowThreads(__tstate);
50513 if (PyErr_Occurred()) SWIG_fail;
50514 }
50515 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50516 return resultobj;
50517 fail:
50518 return NULL;
50519 }
50520
50521
50522 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50523 int argc;
50524 PyObject *argv[3];
50525
50526 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50527 --argc;
50528 if (argc == 2) {
50529 int _v = 0;
50530 {
50531 void *vptr = 0;
50532 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50533 _v = SWIG_CheckState(res);
50534 }
50535 if (!_v) goto check_1;
50536 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50537 }
50538 check_1:
50539
50540 if (argc == 2) {
50541 int _v = 0;
50542 {
50543 void *vptr = 0;
50544 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50545 _v = SWIG_CheckState(res);
50546 }
50547 if (!_v) goto check_2;
50548 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50549 }
50550 check_2:
50551
50552 if (argc == 2) {
50553 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50554 }
50555
50556 fail:
50557 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50558 return NULL;
50559 }
50560
50561
50562 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50563 PyObject *resultobj = 0;
50564 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50565 wxWindow *arg2 = (wxWindow *) 0 ;
50566 wxGBSpan *arg3 = 0 ;
50567 bool result;
50568 void *argp1 = 0 ;
50569 int res1 = 0 ;
50570 void *argp2 = 0 ;
50571 int res2 = 0 ;
50572 wxGBSpan temp3 ;
50573
50574 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50576 if (!SWIG_IsOK(res1)) {
50577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50578 }
50579 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50580 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50581 if (!SWIG_IsOK(res2)) {
50582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50583 }
50584 arg2 = reinterpret_cast< wxWindow * >(argp2);
50585 {
50586 arg3 = &temp3;
50587 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50588 }
50589 {
50590 PyThreadState* __tstate = wxPyBeginAllowThreads();
50591 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50592 wxPyEndAllowThreads(__tstate);
50593 if (PyErr_Occurred()) SWIG_fail;
50594 }
50595 {
50596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50597 }
50598 return resultobj;
50599 fail:
50600 return NULL;
50601 }
50602
50603
50604 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50605 PyObject *resultobj = 0;
50606 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50607 wxSizer *arg2 = (wxSizer *) 0 ;
50608 wxGBSpan *arg3 = 0 ;
50609 bool result;
50610 void *argp1 = 0 ;
50611 int res1 = 0 ;
50612 void *argp2 = 0 ;
50613 int res2 = 0 ;
50614 wxGBSpan temp3 ;
50615
50616 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50620 }
50621 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50623 if (!SWIG_IsOK(res2)) {
50624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50625 }
50626 arg2 = reinterpret_cast< wxSizer * >(argp2);
50627 {
50628 arg3 = &temp3;
50629 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50630 }
50631 {
50632 PyThreadState* __tstate = wxPyBeginAllowThreads();
50633 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50634 wxPyEndAllowThreads(__tstate);
50635 if (PyErr_Occurred()) SWIG_fail;
50636 }
50637 {
50638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50639 }
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50647 PyObject *resultobj = 0;
50648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50649 size_t arg2 ;
50650 wxGBSpan *arg3 = 0 ;
50651 bool result;
50652 void *argp1 = 0 ;
50653 int res1 = 0 ;
50654 size_t val2 ;
50655 int ecode2 = 0 ;
50656 wxGBSpan temp3 ;
50657
50658 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50660 if (!SWIG_IsOK(res1)) {
50661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50662 }
50663 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50664 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50665 if (!SWIG_IsOK(ecode2)) {
50666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50667 }
50668 arg2 = static_cast< size_t >(val2);
50669 {
50670 arg3 = &temp3;
50671 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50672 }
50673 {
50674 PyThreadState* __tstate = wxPyBeginAllowThreads();
50675 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50676 wxPyEndAllowThreads(__tstate);
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_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50689 int argc;
50690 PyObject *argv[4];
50691
50692 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50693 --argc;
50694 if (argc == 3) {
50695 int _v = 0;
50696 {
50697 void *vptr = 0;
50698 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50699 _v = SWIG_CheckState(res);
50700 }
50701 if (!_v) goto check_1;
50702 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50703 }
50704 check_1:
50705
50706 if (argc == 3) {
50707 int _v = 0;
50708 {
50709 void *vptr = 0;
50710 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50711 _v = SWIG_CheckState(res);
50712 }
50713 if (!_v) goto check_2;
50714 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50715 }
50716 check_2:
50717
50718 if (argc == 3) {
50719 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50720 }
50721
50722 fail:
50723 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50724 return NULL;
50725 }
50726
50727
50728 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50729 PyObject *resultobj = 0;
50730 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50731 wxWindow *arg2 = (wxWindow *) 0 ;
50732 wxGBSizerItem *result = 0 ;
50733 void *argp1 = 0 ;
50734 int res1 = 0 ;
50735 void *argp2 = 0 ;
50736 int res2 = 0 ;
50737
50738 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50740 if (!SWIG_IsOK(res1)) {
50741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50742 }
50743 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50745 if (!SWIG_IsOK(res2)) {
50746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50747 }
50748 arg2 = reinterpret_cast< wxWindow * >(argp2);
50749 {
50750 PyThreadState* __tstate = wxPyBeginAllowThreads();
50751 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50752 wxPyEndAllowThreads(__tstate);
50753 if (PyErr_Occurred()) SWIG_fail;
50754 }
50755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50756 return resultobj;
50757 fail:
50758 return NULL;
50759 }
50760
50761
50762 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50763 PyObject *resultobj = 0;
50764 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50765 wxSizer *arg2 = (wxSizer *) 0 ;
50766 wxGBSizerItem *result = 0 ;
50767 void *argp1 = 0 ;
50768 int res1 = 0 ;
50769 void *argp2 = 0 ;
50770 int res2 = 0 ;
50771
50772 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50774 if (!SWIG_IsOK(res1)) {
50775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50776 }
50777 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50778 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50779 if (!SWIG_IsOK(res2)) {
50780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50781 }
50782 arg2 = reinterpret_cast< wxSizer * >(argp2);
50783 {
50784 PyThreadState* __tstate = wxPyBeginAllowThreads();
50785 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50786 wxPyEndAllowThreads(__tstate);
50787 if (PyErr_Occurred()) SWIG_fail;
50788 }
50789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50790 return resultobj;
50791 fail:
50792 return NULL;
50793 }
50794
50795
50796 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50797 int argc;
50798 PyObject *argv[3];
50799
50800 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50801 --argc;
50802 if (argc == 2) {
50803 int _v = 0;
50804 {
50805 void *vptr = 0;
50806 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50807 _v = SWIG_CheckState(res);
50808 }
50809 if (!_v) goto check_1;
50810 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50811 }
50812 check_1:
50813
50814 if (argc == 2) {
50815 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50816 }
50817
50818 fail:
50819 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50820 return NULL;
50821 }
50822
50823
50824 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50825 PyObject *resultobj = 0;
50826 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50827 wxGBPosition *arg2 = 0 ;
50828 wxGBSizerItem *result = 0 ;
50829 void *argp1 = 0 ;
50830 int res1 = 0 ;
50831 wxGBPosition temp2 ;
50832 PyObject * obj0 = 0 ;
50833 PyObject * obj1 = 0 ;
50834 char * kwnames[] = {
50835 (char *) "self",(char *) "pos", NULL
50836 };
50837
50838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50840 if (!SWIG_IsOK(res1)) {
50841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50842 }
50843 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50844 {
50845 arg2 = &temp2;
50846 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50847 }
50848 {
50849 PyThreadState* __tstate = wxPyBeginAllowThreads();
50850 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50851 wxPyEndAllowThreads(__tstate);
50852 if (PyErr_Occurred()) SWIG_fail;
50853 }
50854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50855 return resultobj;
50856 fail:
50857 return NULL;
50858 }
50859
50860
50861 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50862 PyObject *resultobj = 0;
50863 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50864 wxPoint *arg2 = 0 ;
50865 wxGBSizerItem *result = 0 ;
50866 void *argp1 = 0 ;
50867 int res1 = 0 ;
50868 wxPoint temp2 ;
50869 PyObject * obj0 = 0 ;
50870 PyObject * obj1 = 0 ;
50871 char * kwnames[] = {
50872 (char *) "self",(char *) "pt", NULL
50873 };
50874
50875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50877 if (!SWIG_IsOK(res1)) {
50878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50879 }
50880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50881 {
50882 arg2 = &temp2;
50883 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50884 }
50885 {
50886 PyThreadState* __tstate = wxPyBeginAllowThreads();
50887 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50888 wxPyEndAllowThreads(__tstate);
50889 if (PyErr_Occurred()) SWIG_fail;
50890 }
50891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50892 return resultobj;
50893 fail:
50894 return NULL;
50895 }
50896
50897
50898 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50899 PyObject *resultobj = 0;
50900 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50901 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50902 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50903 bool result;
50904 void *argp1 = 0 ;
50905 int res1 = 0 ;
50906 void *argp2 = 0 ;
50907 int res2 = 0 ;
50908 void *argp3 = 0 ;
50909 int res3 = 0 ;
50910 PyObject * obj0 = 0 ;
50911 PyObject * obj1 = 0 ;
50912 PyObject * obj2 = 0 ;
50913 char * kwnames[] = {
50914 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50915 };
50916
50917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50919 if (!SWIG_IsOK(res1)) {
50920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50921 }
50922 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50924 if (!SWIG_IsOK(res2)) {
50925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50926 }
50927 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50928 if (obj2) {
50929 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50930 if (!SWIG_IsOK(res3)) {
50931 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50932 }
50933 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50934 }
50935 {
50936 PyThreadState* __tstate = wxPyBeginAllowThreads();
50937 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50938 wxPyEndAllowThreads(__tstate);
50939 if (PyErr_Occurred()) SWIG_fail;
50940 }
50941 {
50942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50943 }
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50953 wxGBPosition *arg2 = 0 ;
50954 wxGBSpan *arg3 = 0 ;
50955 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50956 bool result;
50957 void *argp1 = 0 ;
50958 int res1 = 0 ;
50959 wxGBPosition temp2 ;
50960 wxGBSpan temp3 ;
50961 void *argp4 = 0 ;
50962 int res4 = 0 ;
50963 PyObject * obj0 = 0 ;
50964 PyObject * obj1 = 0 ;
50965 PyObject * obj2 = 0 ;
50966 PyObject * obj3 = 0 ;
50967 char * kwnames[] = {
50968 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50969 };
50970
50971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50973 if (!SWIG_IsOK(res1)) {
50974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50975 }
50976 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50977 {
50978 arg2 = &temp2;
50979 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50980 }
50981 {
50982 arg3 = &temp3;
50983 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50984 }
50985 if (obj3) {
50986 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50987 if (!SWIG_IsOK(res4)) {
50988 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50989 }
50990 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50991 }
50992 {
50993 PyThreadState* __tstate = wxPyBeginAllowThreads();
50994 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50995 wxPyEndAllowThreads(__tstate);
50996 if (PyErr_Occurred()) SWIG_fail;
50997 }
50998 {
50999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51000 }
51001 return resultobj;
51002 fail:
51003 return NULL;
51004 }
51005
51006
51007 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51008 PyObject *obj;
51009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51010 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51011 return SWIG_Py_Void();
51012 }
51013
51014 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51015 return SWIG_Python_InitShadowInstance(args);
51016 }
51017
51018 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51019 PyObject *resultobj = 0;
51020 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51021 wxRelationship arg2 ;
51022 wxWindow *arg3 = (wxWindow *) 0 ;
51023 wxEdge arg4 ;
51024 int arg5 = (int) 0 ;
51025 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51026 void *argp1 = 0 ;
51027 int res1 = 0 ;
51028 int val2 ;
51029 int ecode2 = 0 ;
51030 void *argp3 = 0 ;
51031 int res3 = 0 ;
51032 int val4 ;
51033 int ecode4 = 0 ;
51034 int val5 ;
51035 int ecode5 = 0 ;
51036 int val6 ;
51037 int ecode6 = 0 ;
51038 PyObject * obj0 = 0 ;
51039 PyObject * obj1 = 0 ;
51040 PyObject * obj2 = 0 ;
51041 PyObject * obj3 = 0 ;
51042 PyObject * obj4 = 0 ;
51043 PyObject * obj5 = 0 ;
51044 char * kwnames[] = {
51045 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51046 };
51047
51048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51050 if (!SWIG_IsOK(res1)) {
51051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51052 }
51053 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51054 ecode2 = SWIG_AsVal_int(obj1, &val2);
51055 if (!SWIG_IsOK(ecode2)) {
51056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51057 }
51058 arg2 = static_cast< wxRelationship >(val2);
51059 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51060 if (!SWIG_IsOK(res3)) {
51061 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51062 }
51063 arg3 = reinterpret_cast< wxWindow * >(argp3);
51064 ecode4 = SWIG_AsVal_int(obj3, &val4);
51065 if (!SWIG_IsOK(ecode4)) {
51066 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51067 }
51068 arg4 = static_cast< wxEdge >(val4);
51069 if (obj4) {
51070 ecode5 = SWIG_AsVal_int(obj4, &val5);
51071 if (!SWIG_IsOK(ecode5)) {
51072 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51073 }
51074 arg5 = static_cast< int >(val5);
51075 }
51076 if (obj5) {
51077 ecode6 = SWIG_AsVal_int(obj5, &val6);
51078 if (!SWIG_IsOK(ecode6)) {
51079 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51080 }
51081 arg6 = static_cast< int >(val6);
51082 }
51083 {
51084 PyThreadState* __tstate = wxPyBeginAllowThreads();
51085 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51086 wxPyEndAllowThreads(__tstate);
51087 if (PyErr_Occurred()) SWIG_fail;
51088 }
51089 resultobj = SWIG_Py_Void();
51090 return resultobj;
51091 fail:
51092 return NULL;
51093 }
51094
51095
51096 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51097 PyObject *resultobj = 0;
51098 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51099 wxWindow *arg2 = (wxWindow *) 0 ;
51100 int arg3 = (int) 0 ;
51101 void *argp1 = 0 ;
51102 int res1 = 0 ;
51103 void *argp2 = 0 ;
51104 int res2 = 0 ;
51105 int val3 ;
51106 int ecode3 = 0 ;
51107 PyObject * obj0 = 0 ;
51108 PyObject * obj1 = 0 ;
51109 PyObject * obj2 = 0 ;
51110 char * kwnames[] = {
51111 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51112 };
51113
51114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51116 if (!SWIG_IsOK(res1)) {
51117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51118 }
51119 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51121 if (!SWIG_IsOK(res2)) {
51122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51123 }
51124 arg2 = reinterpret_cast< wxWindow * >(argp2);
51125 if (obj2) {
51126 ecode3 = SWIG_AsVal_int(obj2, &val3);
51127 if (!SWIG_IsOK(ecode3)) {
51128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51129 }
51130 arg3 = static_cast< int >(val3);
51131 }
51132 {
51133 PyThreadState* __tstate = wxPyBeginAllowThreads();
51134 (arg1)->LeftOf(arg2,arg3);
51135 wxPyEndAllowThreads(__tstate);
51136 if (PyErr_Occurred()) SWIG_fail;
51137 }
51138 resultobj = SWIG_Py_Void();
51139 return resultobj;
51140 fail:
51141 return NULL;
51142 }
51143
51144
51145 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51146 PyObject *resultobj = 0;
51147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51148 wxWindow *arg2 = (wxWindow *) 0 ;
51149 int arg3 = (int) 0 ;
51150 void *argp1 = 0 ;
51151 int res1 = 0 ;
51152 void *argp2 = 0 ;
51153 int res2 = 0 ;
51154 int val3 ;
51155 int ecode3 = 0 ;
51156 PyObject * obj0 = 0 ;
51157 PyObject * obj1 = 0 ;
51158 PyObject * obj2 = 0 ;
51159 char * kwnames[] = {
51160 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51161 };
51162
51163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51165 if (!SWIG_IsOK(res1)) {
51166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51167 }
51168 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51170 if (!SWIG_IsOK(res2)) {
51171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51172 }
51173 arg2 = reinterpret_cast< wxWindow * >(argp2);
51174 if (obj2) {
51175 ecode3 = SWIG_AsVal_int(obj2, &val3);
51176 if (!SWIG_IsOK(ecode3)) {
51177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51178 }
51179 arg3 = static_cast< int >(val3);
51180 }
51181 {
51182 PyThreadState* __tstate = wxPyBeginAllowThreads();
51183 (arg1)->RightOf(arg2,arg3);
51184 wxPyEndAllowThreads(__tstate);
51185 if (PyErr_Occurred()) SWIG_fail;
51186 }
51187 resultobj = SWIG_Py_Void();
51188 return resultobj;
51189 fail:
51190 return NULL;
51191 }
51192
51193
51194 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51195 PyObject *resultobj = 0;
51196 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51197 wxWindow *arg2 = (wxWindow *) 0 ;
51198 int arg3 = (int) 0 ;
51199 void *argp1 = 0 ;
51200 int res1 = 0 ;
51201 void *argp2 = 0 ;
51202 int res2 = 0 ;
51203 int val3 ;
51204 int ecode3 = 0 ;
51205 PyObject * obj0 = 0 ;
51206 PyObject * obj1 = 0 ;
51207 PyObject * obj2 = 0 ;
51208 char * kwnames[] = {
51209 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51210 };
51211
51212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51214 if (!SWIG_IsOK(res1)) {
51215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51216 }
51217 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51218 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51219 if (!SWIG_IsOK(res2)) {
51220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51221 }
51222 arg2 = reinterpret_cast< wxWindow * >(argp2);
51223 if (obj2) {
51224 ecode3 = SWIG_AsVal_int(obj2, &val3);
51225 if (!SWIG_IsOK(ecode3)) {
51226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51227 }
51228 arg3 = static_cast< int >(val3);
51229 }
51230 {
51231 PyThreadState* __tstate = wxPyBeginAllowThreads();
51232 (arg1)->Above(arg2,arg3);
51233 wxPyEndAllowThreads(__tstate);
51234 if (PyErr_Occurred()) SWIG_fail;
51235 }
51236 resultobj = SWIG_Py_Void();
51237 return resultobj;
51238 fail:
51239 return NULL;
51240 }
51241
51242
51243 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51244 PyObject *resultobj = 0;
51245 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51246 wxWindow *arg2 = (wxWindow *) 0 ;
51247 int arg3 = (int) 0 ;
51248 void *argp1 = 0 ;
51249 int res1 = 0 ;
51250 void *argp2 = 0 ;
51251 int res2 = 0 ;
51252 int val3 ;
51253 int ecode3 = 0 ;
51254 PyObject * obj0 = 0 ;
51255 PyObject * obj1 = 0 ;
51256 PyObject * obj2 = 0 ;
51257 char * kwnames[] = {
51258 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51259 };
51260
51261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51263 if (!SWIG_IsOK(res1)) {
51264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51265 }
51266 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51268 if (!SWIG_IsOK(res2)) {
51269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51270 }
51271 arg2 = reinterpret_cast< wxWindow * >(argp2);
51272 if (obj2) {
51273 ecode3 = SWIG_AsVal_int(obj2, &val3);
51274 if (!SWIG_IsOK(ecode3)) {
51275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51276 }
51277 arg3 = static_cast< int >(val3);
51278 }
51279 {
51280 PyThreadState* __tstate = wxPyBeginAllowThreads();
51281 (arg1)->Below(arg2,arg3);
51282 wxPyEndAllowThreads(__tstate);
51283 if (PyErr_Occurred()) SWIG_fail;
51284 }
51285 resultobj = SWIG_Py_Void();
51286 return resultobj;
51287 fail:
51288 return NULL;
51289 }
51290
51291
51292 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51293 PyObject *resultobj = 0;
51294 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51295 wxWindow *arg2 = (wxWindow *) 0 ;
51296 wxEdge arg3 ;
51297 int arg4 = (int) 0 ;
51298 void *argp1 = 0 ;
51299 int res1 = 0 ;
51300 void *argp2 = 0 ;
51301 int res2 = 0 ;
51302 int val3 ;
51303 int ecode3 = 0 ;
51304 int val4 ;
51305 int ecode4 = 0 ;
51306 PyObject * obj0 = 0 ;
51307 PyObject * obj1 = 0 ;
51308 PyObject * obj2 = 0 ;
51309 PyObject * obj3 = 0 ;
51310 char * kwnames[] = {
51311 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51312 };
51313
51314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51316 if (!SWIG_IsOK(res1)) {
51317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51318 }
51319 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51321 if (!SWIG_IsOK(res2)) {
51322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51323 }
51324 arg2 = reinterpret_cast< wxWindow * >(argp2);
51325 ecode3 = SWIG_AsVal_int(obj2, &val3);
51326 if (!SWIG_IsOK(ecode3)) {
51327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51328 }
51329 arg3 = static_cast< wxEdge >(val3);
51330 if (obj3) {
51331 ecode4 = SWIG_AsVal_int(obj3, &val4);
51332 if (!SWIG_IsOK(ecode4)) {
51333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51334 }
51335 arg4 = static_cast< int >(val4);
51336 }
51337 {
51338 PyThreadState* __tstate = wxPyBeginAllowThreads();
51339 (arg1)->SameAs(arg2,arg3,arg4);
51340 wxPyEndAllowThreads(__tstate);
51341 if (PyErr_Occurred()) SWIG_fail;
51342 }
51343 resultobj = SWIG_Py_Void();
51344 return resultobj;
51345 fail:
51346 return NULL;
51347 }
51348
51349
51350 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51351 PyObject *resultobj = 0;
51352 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51353 wxWindow *arg2 = (wxWindow *) 0 ;
51354 wxEdge arg3 ;
51355 int arg4 ;
51356 void *argp1 = 0 ;
51357 int res1 = 0 ;
51358 void *argp2 = 0 ;
51359 int res2 = 0 ;
51360 int val3 ;
51361 int ecode3 = 0 ;
51362 int val4 ;
51363 int ecode4 = 0 ;
51364 PyObject * obj0 = 0 ;
51365 PyObject * obj1 = 0 ;
51366 PyObject * obj2 = 0 ;
51367 PyObject * obj3 = 0 ;
51368 char * kwnames[] = {
51369 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51370 };
51371
51372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51374 if (!SWIG_IsOK(res1)) {
51375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51376 }
51377 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51379 if (!SWIG_IsOK(res2)) {
51380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51381 }
51382 arg2 = reinterpret_cast< wxWindow * >(argp2);
51383 ecode3 = SWIG_AsVal_int(obj2, &val3);
51384 if (!SWIG_IsOK(ecode3)) {
51385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51386 }
51387 arg3 = static_cast< wxEdge >(val3);
51388 ecode4 = SWIG_AsVal_int(obj3, &val4);
51389 if (!SWIG_IsOK(ecode4)) {
51390 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51391 }
51392 arg4 = static_cast< int >(val4);
51393 {
51394 PyThreadState* __tstate = wxPyBeginAllowThreads();
51395 (arg1)->PercentOf(arg2,arg3,arg4);
51396 wxPyEndAllowThreads(__tstate);
51397 if (PyErr_Occurred()) SWIG_fail;
51398 }
51399 resultobj = SWIG_Py_Void();
51400 return resultobj;
51401 fail:
51402 return NULL;
51403 }
51404
51405
51406 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51407 PyObject *resultobj = 0;
51408 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51409 int arg2 ;
51410 void *argp1 = 0 ;
51411 int res1 = 0 ;
51412 int val2 ;
51413 int ecode2 = 0 ;
51414 PyObject * obj0 = 0 ;
51415 PyObject * obj1 = 0 ;
51416 char * kwnames[] = {
51417 (char *) "self",(char *) "val", NULL
51418 };
51419
51420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51422 if (!SWIG_IsOK(res1)) {
51423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51424 }
51425 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51426 ecode2 = SWIG_AsVal_int(obj1, &val2);
51427 if (!SWIG_IsOK(ecode2)) {
51428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51429 }
51430 arg2 = static_cast< int >(val2);
51431 {
51432 PyThreadState* __tstate = wxPyBeginAllowThreads();
51433 (arg1)->Absolute(arg2);
51434 wxPyEndAllowThreads(__tstate);
51435 if (PyErr_Occurred()) SWIG_fail;
51436 }
51437 resultobj = SWIG_Py_Void();
51438 return resultobj;
51439 fail:
51440 return NULL;
51441 }
51442
51443
51444 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51445 PyObject *resultobj = 0;
51446 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51447 void *argp1 = 0 ;
51448 int res1 = 0 ;
51449 PyObject *swig_obj[1] ;
51450
51451 if (!args) SWIG_fail;
51452 swig_obj[0] = args;
51453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51454 if (!SWIG_IsOK(res1)) {
51455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51456 }
51457 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51458 {
51459 PyThreadState* __tstate = wxPyBeginAllowThreads();
51460 (arg1)->Unconstrained();
51461 wxPyEndAllowThreads(__tstate);
51462 if (PyErr_Occurred()) SWIG_fail;
51463 }
51464 resultobj = SWIG_Py_Void();
51465 return resultobj;
51466 fail:
51467 return NULL;
51468 }
51469
51470
51471 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51472 PyObject *resultobj = 0;
51473 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51474 void *argp1 = 0 ;
51475 int res1 = 0 ;
51476 PyObject *swig_obj[1] ;
51477
51478 if (!args) SWIG_fail;
51479 swig_obj[0] = args;
51480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51481 if (!SWIG_IsOK(res1)) {
51482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51483 }
51484 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51485 {
51486 PyThreadState* __tstate = wxPyBeginAllowThreads();
51487 (arg1)->AsIs();
51488 wxPyEndAllowThreads(__tstate);
51489 if (PyErr_Occurred()) SWIG_fail;
51490 }
51491 resultobj = SWIG_Py_Void();
51492 return resultobj;
51493 fail:
51494 return NULL;
51495 }
51496
51497
51498 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51499 PyObject *resultobj = 0;
51500 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51501 wxWindow *result = 0 ;
51502 void *argp1 = 0 ;
51503 int res1 = 0 ;
51504 PyObject *swig_obj[1] ;
51505
51506 if (!args) SWIG_fail;
51507 swig_obj[0] = args;
51508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51509 if (!SWIG_IsOK(res1)) {
51510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51511 }
51512 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51513 {
51514 PyThreadState* __tstate = wxPyBeginAllowThreads();
51515 result = (wxWindow *)(arg1)->GetOtherWindow();
51516 wxPyEndAllowThreads(__tstate);
51517 if (PyErr_Occurred()) SWIG_fail;
51518 }
51519 {
51520 resultobj = wxPyMake_wxObject(result, 0);
51521 }
51522 return resultobj;
51523 fail:
51524 return NULL;
51525 }
51526
51527
51528 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51529 PyObject *resultobj = 0;
51530 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51531 wxEdge result;
51532 void *argp1 = 0 ;
51533 int res1 = 0 ;
51534 PyObject *swig_obj[1] ;
51535
51536 if (!args) SWIG_fail;
51537 swig_obj[0] = args;
51538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51539 if (!SWIG_IsOK(res1)) {
51540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51541 }
51542 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51543 {
51544 PyThreadState* __tstate = wxPyBeginAllowThreads();
51545 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51546 wxPyEndAllowThreads(__tstate);
51547 if (PyErr_Occurred()) SWIG_fail;
51548 }
51549 resultobj = SWIG_From_int(static_cast< int >(result));
51550 return resultobj;
51551 fail:
51552 return NULL;
51553 }
51554
51555
51556 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51557 PyObject *resultobj = 0;
51558 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51559 wxEdge arg2 ;
51560 void *argp1 = 0 ;
51561 int res1 = 0 ;
51562 int val2 ;
51563 int ecode2 = 0 ;
51564 PyObject * obj0 = 0 ;
51565 PyObject * obj1 = 0 ;
51566 char * kwnames[] = {
51567 (char *) "self",(char *) "which", NULL
51568 };
51569
51570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51572 if (!SWIG_IsOK(res1)) {
51573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51574 }
51575 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51576 ecode2 = SWIG_AsVal_int(obj1, &val2);
51577 if (!SWIG_IsOK(ecode2)) {
51578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51579 }
51580 arg2 = static_cast< wxEdge >(val2);
51581 {
51582 PyThreadState* __tstate = wxPyBeginAllowThreads();
51583 (arg1)->SetEdge(arg2);
51584 wxPyEndAllowThreads(__tstate);
51585 if (PyErr_Occurred()) SWIG_fail;
51586 }
51587 resultobj = SWIG_Py_Void();
51588 return resultobj;
51589 fail:
51590 return NULL;
51591 }
51592
51593
51594 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51595 PyObject *resultobj = 0;
51596 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51597 int arg2 ;
51598 void *argp1 = 0 ;
51599 int res1 = 0 ;
51600 int val2 ;
51601 int ecode2 = 0 ;
51602 PyObject * obj0 = 0 ;
51603 PyObject * obj1 = 0 ;
51604 char * kwnames[] = {
51605 (char *) "self",(char *) "v", NULL
51606 };
51607
51608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51610 if (!SWIG_IsOK(res1)) {
51611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51612 }
51613 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51614 ecode2 = SWIG_AsVal_int(obj1, &val2);
51615 if (!SWIG_IsOK(ecode2)) {
51616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51617 }
51618 arg2 = static_cast< int >(val2);
51619 {
51620 PyThreadState* __tstate = wxPyBeginAllowThreads();
51621 (arg1)->SetValue(arg2);
51622 wxPyEndAllowThreads(__tstate);
51623 if (PyErr_Occurred()) SWIG_fail;
51624 }
51625 resultobj = SWIG_Py_Void();
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51633 PyObject *resultobj = 0;
51634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51635 int result;
51636 void *argp1 = 0 ;
51637 int res1 = 0 ;
51638 PyObject *swig_obj[1] ;
51639
51640 if (!args) SWIG_fail;
51641 swig_obj[0] = args;
51642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51643 if (!SWIG_IsOK(res1)) {
51644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51645 }
51646 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51647 {
51648 PyThreadState* __tstate = wxPyBeginAllowThreads();
51649 result = (int)(arg1)->GetMargin();
51650 wxPyEndAllowThreads(__tstate);
51651 if (PyErr_Occurred()) SWIG_fail;
51652 }
51653 resultobj = SWIG_From_int(static_cast< int >(result));
51654 return resultobj;
51655 fail:
51656 return NULL;
51657 }
51658
51659
51660 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51661 PyObject *resultobj = 0;
51662 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51663 int arg2 ;
51664 void *argp1 = 0 ;
51665 int res1 = 0 ;
51666 int val2 ;
51667 int ecode2 = 0 ;
51668 PyObject * obj0 = 0 ;
51669 PyObject * obj1 = 0 ;
51670 char * kwnames[] = {
51671 (char *) "self",(char *) "m", NULL
51672 };
51673
51674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51676 if (!SWIG_IsOK(res1)) {
51677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51678 }
51679 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51680 ecode2 = SWIG_AsVal_int(obj1, &val2);
51681 if (!SWIG_IsOK(ecode2)) {
51682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51683 }
51684 arg2 = static_cast< int >(val2);
51685 {
51686 PyThreadState* __tstate = wxPyBeginAllowThreads();
51687 (arg1)->SetMargin(arg2);
51688 wxPyEndAllowThreads(__tstate);
51689 if (PyErr_Occurred()) SWIG_fail;
51690 }
51691 resultobj = SWIG_Py_Void();
51692 return resultobj;
51693 fail:
51694 return NULL;
51695 }
51696
51697
51698 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51699 PyObject *resultobj = 0;
51700 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51701 int result;
51702 void *argp1 = 0 ;
51703 int res1 = 0 ;
51704 PyObject *swig_obj[1] ;
51705
51706 if (!args) SWIG_fail;
51707 swig_obj[0] = args;
51708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51709 if (!SWIG_IsOK(res1)) {
51710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51711 }
51712 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51713 {
51714 PyThreadState* __tstate = wxPyBeginAllowThreads();
51715 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51716 wxPyEndAllowThreads(__tstate);
51717 if (PyErr_Occurred()) SWIG_fail;
51718 }
51719 resultobj = SWIG_From_int(static_cast< int >(result));
51720 return resultobj;
51721 fail:
51722 return NULL;
51723 }
51724
51725
51726 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51727 PyObject *resultobj = 0;
51728 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51729 int result;
51730 void *argp1 = 0 ;
51731 int res1 = 0 ;
51732 PyObject *swig_obj[1] ;
51733
51734 if (!args) SWIG_fail;
51735 swig_obj[0] = args;
51736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51737 if (!SWIG_IsOK(res1)) {
51738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51739 }
51740 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51741 {
51742 PyThreadState* __tstate = wxPyBeginAllowThreads();
51743 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51744 wxPyEndAllowThreads(__tstate);
51745 if (PyErr_Occurred()) SWIG_fail;
51746 }
51747 resultobj = SWIG_From_int(static_cast< int >(result));
51748 return resultobj;
51749 fail:
51750 return NULL;
51751 }
51752
51753
51754 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51755 PyObject *resultobj = 0;
51756 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51757 int result;
51758 void *argp1 = 0 ;
51759 int res1 = 0 ;
51760 PyObject *swig_obj[1] ;
51761
51762 if (!args) SWIG_fail;
51763 swig_obj[0] = args;
51764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51765 if (!SWIG_IsOK(res1)) {
51766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51767 }
51768 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51769 {
51770 PyThreadState* __tstate = wxPyBeginAllowThreads();
51771 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51772 wxPyEndAllowThreads(__tstate);
51773 if (PyErr_Occurred()) SWIG_fail;
51774 }
51775 resultobj = SWIG_From_int(static_cast< int >(result));
51776 return resultobj;
51777 fail:
51778 return NULL;
51779 }
51780
51781
51782 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51783 PyObject *resultobj = 0;
51784 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51785 bool result;
51786 void *argp1 = 0 ;
51787 int res1 = 0 ;
51788 PyObject *swig_obj[1] ;
51789
51790 if (!args) SWIG_fail;
51791 swig_obj[0] = args;
51792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51793 if (!SWIG_IsOK(res1)) {
51794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51795 }
51796 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 {
51804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51805 }
51806 return resultobj;
51807 fail:
51808 return NULL;
51809 }
51810
51811
51812 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51813 PyObject *resultobj = 0;
51814 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51815 bool arg2 ;
51816 void *argp1 = 0 ;
51817 int res1 = 0 ;
51818 bool val2 ;
51819 int ecode2 = 0 ;
51820 PyObject * obj0 = 0 ;
51821 PyObject * obj1 = 0 ;
51822 char * kwnames[] = {
51823 (char *) "self",(char *) "d", NULL
51824 };
51825
51826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51828 if (!SWIG_IsOK(res1)) {
51829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51830 }
51831 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51832 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51833 if (!SWIG_IsOK(ecode2)) {
51834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51835 }
51836 arg2 = static_cast< bool >(val2);
51837 {
51838 PyThreadState* __tstate = wxPyBeginAllowThreads();
51839 (arg1)->SetDone(arg2);
51840 wxPyEndAllowThreads(__tstate);
51841 if (PyErr_Occurred()) SWIG_fail;
51842 }
51843 resultobj = SWIG_Py_Void();
51844 return resultobj;
51845 fail:
51846 return NULL;
51847 }
51848
51849
51850 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51851 PyObject *resultobj = 0;
51852 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51853 wxRelationship result;
51854 void *argp1 = 0 ;
51855 int res1 = 0 ;
51856 PyObject *swig_obj[1] ;
51857
51858 if (!args) SWIG_fail;
51859 swig_obj[0] = args;
51860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51861 if (!SWIG_IsOK(res1)) {
51862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51863 }
51864 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51865 {
51866 PyThreadState* __tstate = wxPyBeginAllowThreads();
51867 result = (wxRelationship)(arg1)->GetRelationship();
51868 wxPyEndAllowThreads(__tstate);
51869 if (PyErr_Occurred()) SWIG_fail;
51870 }
51871 resultobj = SWIG_From_int(static_cast< int >(result));
51872 return resultobj;
51873 fail:
51874 return NULL;
51875 }
51876
51877
51878 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51879 PyObject *resultobj = 0;
51880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51881 wxRelationship arg2 ;
51882 void *argp1 = 0 ;
51883 int res1 = 0 ;
51884 int val2 ;
51885 int ecode2 = 0 ;
51886 PyObject * obj0 = 0 ;
51887 PyObject * obj1 = 0 ;
51888 char * kwnames[] = {
51889 (char *) "self",(char *) "r", NULL
51890 };
51891
51892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51894 if (!SWIG_IsOK(res1)) {
51895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51896 }
51897 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51898 ecode2 = SWIG_AsVal_int(obj1, &val2);
51899 if (!SWIG_IsOK(ecode2)) {
51900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51901 }
51902 arg2 = static_cast< wxRelationship >(val2);
51903 {
51904 PyThreadState* __tstate = wxPyBeginAllowThreads();
51905 (arg1)->SetRelationship(arg2);
51906 wxPyEndAllowThreads(__tstate);
51907 if (PyErr_Occurred()) SWIG_fail;
51908 }
51909 resultobj = SWIG_Py_Void();
51910 return resultobj;
51911 fail:
51912 return NULL;
51913 }
51914
51915
51916 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51917 PyObject *resultobj = 0;
51918 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51919 wxWindow *arg2 = (wxWindow *) 0 ;
51920 bool result;
51921 void *argp1 = 0 ;
51922 int res1 = 0 ;
51923 void *argp2 = 0 ;
51924 int res2 = 0 ;
51925 PyObject * obj0 = 0 ;
51926 PyObject * obj1 = 0 ;
51927 char * kwnames[] = {
51928 (char *) "self",(char *) "otherW", NULL
51929 };
51930
51931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51933 if (!SWIG_IsOK(res1)) {
51934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51935 }
51936 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51938 if (!SWIG_IsOK(res2)) {
51939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51940 }
51941 arg2 = reinterpret_cast< wxWindow * >(argp2);
51942 {
51943 PyThreadState* __tstate = wxPyBeginAllowThreads();
51944 result = (bool)(arg1)->ResetIfWin(arg2);
51945 wxPyEndAllowThreads(__tstate);
51946 if (PyErr_Occurred()) SWIG_fail;
51947 }
51948 {
51949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51950 }
51951 return resultobj;
51952 fail:
51953 return NULL;
51954 }
51955
51956
51957 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51958 PyObject *resultobj = 0;
51959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51960 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51961 wxWindow *arg3 = (wxWindow *) 0 ;
51962 bool result;
51963 void *argp1 = 0 ;
51964 int res1 = 0 ;
51965 void *argp2 = 0 ;
51966 int res2 = 0 ;
51967 void *argp3 = 0 ;
51968 int res3 = 0 ;
51969 PyObject * obj0 = 0 ;
51970 PyObject * obj1 = 0 ;
51971 PyObject * obj2 = 0 ;
51972 char * kwnames[] = {
51973 (char *) "self",(char *) "constraints",(char *) "win", NULL
51974 };
51975
51976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51978 if (!SWIG_IsOK(res1)) {
51979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51980 }
51981 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51982 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51983 if (!SWIG_IsOK(res2)) {
51984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51985 }
51986 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51987 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51988 if (!SWIG_IsOK(res3)) {
51989 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51990 }
51991 arg3 = reinterpret_cast< wxWindow * >(argp3);
51992 {
51993 PyThreadState* __tstate = wxPyBeginAllowThreads();
51994 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51995 wxPyEndAllowThreads(__tstate);
51996 if (PyErr_Occurred()) SWIG_fail;
51997 }
51998 {
51999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52000 }
52001 return resultobj;
52002 fail:
52003 return NULL;
52004 }
52005
52006
52007 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52008 PyObject *resultobj = 0;
52009 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52010 wxEdge arg2 ;
52011 wxWindow *arg3 = (wxWindow *) 0 ;
52012 wxWindow *arg4 = (wxWindow *) 0 ;
52013 int result;
52014 void *argp1 = 0 ;
52015 int res1 = 0 ;
52016 int val2 ;
52017 int ecode2 = 0 ;
52018 void *argp3 = 0 ;
52019 int res3 = 0 ;
52020 void *argp4 = 0 ;
52021 int res4 = 0 ;
52022 PyObject * obj0 = 0 ;
52023 PyObject * obj1 = 0 ;
52024 PyObject * obj2 = 0 ;
52025 PyObject * obj3 = 0 ;
52026 char * kwnames[] = {
52027 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52028 };
52029
52030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52032 if (!SWIG_IsOK(res1)) {
52033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52034 }
52035 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52036 ecode2 = SWIG_AsVal_int(obj1, &val2);
52037 if (!SWIG_IsOK(ecode2)) {
52038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52039 }
52040 arg2 = static_cast< wxEdge >(val2);
52041 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52042 if (!SWIG_IsOK(res3)) {
52043 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52044 }
52045 arg3 = reinterpret_cast< wxWindow * >(argp3);
52046 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52047 if (!SWIG_IsOK(res4)) {
52048 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52049 }
52050 arg4 = reinterpret_cast< wxWindow * >(argp4);
52051 {
52052 PyThreadState* __tstate = wxPyBeginAllowThreads();
52053 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52054 wxPyEndAllowThreads(__tstate);
52055 if (PyErr_Occurred()) SWIG_fail;
52056 }
52057 resultobj = SWIG_From_int(static_cast< int >(result));
52058 return resultobj;
52059 fail:
52060 return NULL;
52061 }
52062
52063
52064 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52065 PyObject *obj;
52066 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52067 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52068 return SWIG_Py_Void();
52069 }
52070
52071 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52072 PyObject *resultobj = 0;
52073 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52074 wxIndividualLayoutConstraint *result = 0 ;
52075 void *argp1 = 0 ;
52076 int res1 = 0 ;
52077 PyObject *swig_obj[1] ;
52078
52079 if (!args) SWIG_fail;
52080 swig_obj[0] = args;
52081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52082 if (!SWIG_IsOK(res1)) {
52083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52084 }
52085 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52086 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52087 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52088 return resultobj;
52089 fail:
52090 return NULL;
52091 }
52092
52093
52094 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52095 PyObject *resultobj = 0;
52096 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52097 wxIndividualLayoutConstraint *result = 0 ;
52098 void *argp1 = 0 ;
52099 int res1 = 0 ;
52100 PyObject *swig_obj[1] ;
52101
52102 if (!args) SWIG_fail;
52103 swig_obj[0] = args;
52104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52105 if (!SWIG_IsOK(res1)) {
52106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52107 }
52108 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52109 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52111 return resultobj;
52112 fail:
52113 return NULL;
52114 }
52115
52116
52117 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52118 PyObject *resultobj = 0;
52119 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52120 wxIndividualLayoutConstraint *result = 0 ;
52121 void *argp1 = 0 ;
52122 int res1 = 0 ;
52123 PyObject *swig_obj[1] ;
52124
52125 if (!args) SWIG_fail;
52126 swig_obj[0] = args;
52127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52128 if (!SWIG_IsOK(res1)) {
52129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52130 }
52131 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52132 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52134 return resultobj;
52135 fail:
52136 return NULL;
52137 }
52138
52139
52140 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52141 PyObject *resultobj = 0;
52142 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52143 wxIndividualLayoutConstraint *result = 0 ;
52144 void *argp1 = 0 ;
52145 int res1 = 0 ;
52146 PyObject *swig_obj[1] ;
52147
52148 if (!args) SWIG_fail;
52149 swig_obj[0] = args;
52150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52151 if (!SWIG_IsOK(res1)) {
52152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52153 }
52154 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52155 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52157 return resultobj;
52158 fail:
52159 return NULL;
52160 }
52161
52162
52163 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52164 PyObject *resultobj = 0;
52165 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52166 wxIndividualLayoutConstraint *result = 0 ;
52167 void *argp1 = 0 ;
52168 int res1 = 0 ;
52169 PyObject *swig_obj[1] ;
52170
52171 if (!args) SWIG_fail;
52172 swig_obj[0] = args;
52173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52174 if (!SWIG_IsOK(res1)) {
52175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52176 }
52177 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52178 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52180 return resultobj;
52181 fail:
52182 return NULL;
52183 }
52184
52185
52186 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52187 PyObject *resultobj = 0;
52188 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52189 wxIndividualLayoutConstraint *result = 0 ;
52190 void *argp1 = 0 ;
52191 int res1 = 0 ;
52192 PyObject *swig_obj[1] ;
52193
52194 if (!args) SWIG_fail;
52195 swig_obj[0] = args;
52196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52197 if (!SWIG_IsOK(res1)) {
52198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52199 }
52200 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52201 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52203 return resultobj;
52204 fail:
52205 return NULL;
52206 }
52207
52208
52209 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52210 PyObject *resultobj = 0;
52211 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52212 wxIndividualLayoutConstraint *result = 0 ;
52213 void *argp1 = 0 ;
52214 int res1 = 0 ;
52215 PyObject *swig_obj[1] ;
52216
52217 if (!args) SWIG_fail;
52218 swig_obj[0] = args;
52219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52220 if (!SWIG_IsOK(res1)) {
52221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52222 }
52223 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52224 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52226 return resultobj;
52227 fail:
52228 return NULL;
52229 }
52230
52231
52232 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52233 PyObject *resultobj = 0;
52234 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52235 wxIndividualLayoutConstraint *result = 0 ;
52236 void *argp1 = 0 ;
52237 int res1 = 0 ;
52238 PyObject *swig_obj[1] ;
52239
52240 if (!args) SWIG_fail;
52241 swig_obj[0] = args;
52242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52243 if (!SWIG_IsOK(res1)) {
52244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52245 }
52246 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52247 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52249 return resultobj;
52250 fail:
52251 return NULL;
52252 }
52253
52254
52255 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52256 PyObject *resultobj = 0;
52257 wxLayoutConstraints *result = 0 ;
52258
52259 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52260 {
52261 PyThreadState* __tstate = wxPyBeginAllowThreads();
52262 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52263 wxPyEndAllowThreads(__tstate);
52264 if (PyErr_Occurred()) SWIG_fail;
52265 }
52266 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52267 return resultobj;
52268 fail:
52269 return NULL;
52270 }
52271
52272
52273 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52274 PyObject *resultobj = 0;
52275 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52276 void *argp1 = 0 ;
52277 int res1 = 0 ;
52278 PyObject *swig_obj[1] ;
52279
52280 if (!args) SWIG_fail;
52281 swig_obj[0] = args;
52282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52283 if (!SWIG_IsOK(res1)) {
52284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52285 }
52286 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52287 {
52288 PyThreadState* __tstate = wxPyBeginAllowThreads();
52289 delete arg1;
52290
52291 wxPyEndAllowThreads(__tstate);
52292 if (PyErr_Occurred()) SWIG_fail;
52293 }
52294 resultobj = SWIG_Py_Void();
52295 return resultobj;
52296 fail:
52297 return NULL;
52298 }
52299
52300
52301 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52302 PyObject *resultobj = 0;
52303 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52304 wxWindow *arg2 = (wxWindow *) 0 ;
52305 int *arg3 = (int *) 0 ;
52306 bool result;
52307 void *argp1 = 0 ;
52308 int res1 = 0 ;
52309 void *argp2 = 0 ;
52310 int res2 = 0 ;
52311 int temp3 ;
52312 int res3 = SWIG_TMPOBJ ;
52313 PyObject * obj0 = 0 ;
52314 PyObject * obj1 = 0 ;
52315 char * kwnames[] = {
52316 (char *) "self",(char *) "win", NULL
52317 };
52318
52319 arg3 = &temp3;
52320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52324 }
52325 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52326 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52327 if (!SWIG_IsOK(res2)) {
52328 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52329 }
52330 arg2 = reinterpret_cast< wxWindow * >(argp2);
52331 {
52332 PyThreadState* __tstate = wxPyBeginAllowThreads();
52333 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52334 wxPyEndAllowThreads(__tstate);
52335 if (PyErr_Occurred()) SWIG_fail;
52336 }
52337 {
52338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52339 }
52340 if (SWIG_IsTmpObj(res3)) {
52341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52342 } else {
52343 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52344 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52345 }
52346 return resultobj;
52347 fail:
52348 return NULL;
52349 }
52350
52351
52352 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52353 PyObject *resultobj = 0;
52354 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52355 bool result;
52356 void *argp1 = 0 ;
52357 int res1 = 0 ;
52358 PyObject *swig_obj[1] ;
52359
52360 if (!args) SWIG_fail;
52361 swig_obj[0] = args;
52362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52363 if (!SWIG_IsOK(res1)) {
52364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52365 }
52366 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52367 {
52368 PyThreadState* __tstate = wxPyBeginAllowThreads();
52369 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52370 wxPyEndAllowThreads(__tstate);
52371 if (PyErr_Occurred()) SWIG_fail;
52372 }
52373 {
52374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52375 }
52376 return resultobj;
52377 fail:
52378 return NULL;
52379 }
52380
52381
52382 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52383 PyObject *obj;
52384 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52385 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52386 return SWIG_Py_Void();
52387 }
52388
52389 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52390 return SWIG_Python_InitShadowInstance(args);
52391 }
52392
52393 static PyMethodDef SwigMethods[] = {
52394 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52395 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52396 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52397 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52398 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52399 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52400 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52401 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52402 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52403 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52404 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52405 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52406 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52407 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52408 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52409 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52411 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52415 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52416 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52417 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52419 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52420 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52421 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52422 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52423 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52424 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52425 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52427 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52430 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52432 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52433 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52434 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52435 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52436 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52437 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52438 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52439 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52441 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52447 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52449 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52450 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52451 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52454 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52456 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52457 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52458 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52459 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52460 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52461 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52462 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52463 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52464 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52465 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52467 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52469 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52470 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52471 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52472 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52473 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52474 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52475 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52476 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52477 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52480 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52487 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52489 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52490 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52496 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52497 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52498 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52499 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52500 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52501 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52502 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52503 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52505 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52506 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52507 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52512 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52513 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52514 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52515 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52516 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52519 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52520 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52522 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52523 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52524 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52525 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52528 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52529 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52530 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52531 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52532 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52533 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52534 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52535 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52536 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52538 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52539 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52540 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52541 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52542 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52546 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52547 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52548 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52549 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52550 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52551 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52552 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52553 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52554 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52555 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52556 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52558 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52559 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52561 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52562 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52563 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52564 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52565 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52566 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52567 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52568 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52569 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52570 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52571 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52576 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52582 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52583 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52584 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52585 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52586 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52587 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52590 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52591 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52592 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52595 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52596 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52597 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52600 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52601 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52602 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52603 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52604 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52605 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52606 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52607 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52608 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52612 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52617 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52618 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52619 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52620 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52621 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52622 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52623 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52627 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52629 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52630 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52632 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52633 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52634 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52639 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52640 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52641 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52643 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52644 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52645 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52646 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52647 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52648 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52649 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52650 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52652 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52653 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52654 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52655 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52656 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52657 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52658 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52659 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52661 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52667 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52670 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52682 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52683 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52698 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52699 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52700 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52701 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52702 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52704 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52706 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52708 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52710 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52712 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52715 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52716 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52717 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52718 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52720 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52721 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52728 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52729 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52731 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52732 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52733 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52734 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52735 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52737 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52738 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52739 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52740 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52744 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52745 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52746 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52747 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52748 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52749 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52750 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52751 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52752 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52753 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52754 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52755 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52756 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52757 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52758 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52759 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52760 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52761 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52762 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52763 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52764 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52765 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52766 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52767 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52768 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52769 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52770 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52771 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52772 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52773 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52774 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52775 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52776 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52777 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52778 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52780 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52781 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52782 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52783 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52786 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52788 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52790 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52792 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52793 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52794 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52795 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52796 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52797 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52799 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52800 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52802 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52804 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52806 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52808 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52809 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52810 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52812 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52813 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52815 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52816 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52817 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52819 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52820 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52821 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52822 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52823 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52824 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52825 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52826 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52827 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52828 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52829 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52831 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52832 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52834 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52835 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52836 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52838 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52839 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52840 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52841 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52842 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52844 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52845 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52848 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52849 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52851 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52852 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52855 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52856 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52858 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52864 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52865 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52866 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52867 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52868 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52869 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52870 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52871 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52872 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52873 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52874 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52875 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52876 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52877 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52878 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52879 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52880 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52881 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52882 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52883 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52884 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52885 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52886 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52887 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52889 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52890 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52891 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52892 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52893 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52894 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52895 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52896 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52897 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52898 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52899 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52900 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52901 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52902 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52903 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52904 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52905 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52906 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52907 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52908 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52909 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52910 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52911 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52912 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52913 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52914 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52915 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52916 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52917 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52918 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52919 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52920 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52922 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52923 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52925 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52926 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52927 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52928 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52930 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52931 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52932 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52933 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52934 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52935 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52936 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52937 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52938 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52939 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52940 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52941 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52942 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52943 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52944 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52945 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52946 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52947 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52948 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52949 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52950 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52951 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52952 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52953 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52954 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52955 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52956 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52957 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52958 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52959 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52960 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52961 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52962 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52963 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52964 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52965 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52966 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52968 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52969 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52970 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52972 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52973 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52974 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52975 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52976 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52977 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52979 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52980 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52983 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52984 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52986 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52987 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52989 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52990 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52992 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52993 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52994 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52996 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52997 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52998 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52999 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53001 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53002 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53003 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53005 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53006 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53007 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53009 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53010 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53012 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53013 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53014 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53015 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53016 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53019 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53021 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53023 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53024 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53025 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53028 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53029 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53032 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53033 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53034 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53036 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53037 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53038 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53039 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53040 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53041 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53043 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53044 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53045 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53046 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53047 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53048 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53049 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53050 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53056 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53058 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53060 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53061 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53062 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53063 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53064 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53065 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53067 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53068 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53069 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53070 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53071 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53072 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53075 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53076 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53077 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53080 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53081 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53082 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53083 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53084 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53086 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53088 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53091 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53093 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53094 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53096 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53097 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53098 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53100 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53101 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53102 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53104 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53106 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53107 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53108 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53110 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53112 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53114 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53115 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53117 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53119 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53120 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53121 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53123 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53125 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53126 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53127 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53129 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53131 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53132 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53133 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53134 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53136 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53138 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53140 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53142 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53143 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53145 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53146 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53147 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53148 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53149 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53150 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53151 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53152 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53153 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53154 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53156 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53158 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53160 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53162 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53164 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53165 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53166 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53167 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53168 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53169 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53175 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53176 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53177 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53178 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53179 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53180 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53181 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53182 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53183 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53185 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53186 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53188 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53189 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53190 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53191 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53193 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53194 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53195 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53196 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53198 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53199 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53201 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53202 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53203 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53205 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53207 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53208 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53209 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53210 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53211 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53213 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53214 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53215 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53216 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53217 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53218 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53219 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53220 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53221 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53222 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53223 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53224 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53225 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53226 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53227 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53229 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53232 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53233 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53234 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53236 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53238 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53240 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53242 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53243 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53247 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53253 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53254 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53258 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53259 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53260 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53261 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53262 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53263 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53264 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53265 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53266 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53267 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53268 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53269 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53270 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53271 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53272 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53274 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53275 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53278 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53279 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53280 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53284 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53285 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53288 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53289 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53290 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53291 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53294 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53295 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53296 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53298 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53300 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53301 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53302 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53304 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53306 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53308 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53311 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53312 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53313 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53314 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53315 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53316 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53317 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53323 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53324 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53325 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53326 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53332 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53338 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53339 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53340 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53341 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53342 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53344 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53354 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53355 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53356 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53357 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53360 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53361 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53362 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53363 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53365 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53366 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53370 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53376 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53377 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53378 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53379 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53381 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53382 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53384 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53387 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53389 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53390 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53391 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53400 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53404 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53406 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53415 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53416 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53417 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53418 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53419 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53422 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53425 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53427 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53430 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53432 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53433 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53436 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53438 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53439 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53440 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53441 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53442 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53447 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53448 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53449 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53451 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53452 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53453 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53455 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53457 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53458 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53459 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53461 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53462 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53465 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53472 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53479 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53487 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53490 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53491 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53504 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53506 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53508 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53509 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53511 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53513 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53514 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53516 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53517 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53518 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53522 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53535 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53541 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53542 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53544 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53546 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53547 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53548 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53550 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53551 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53554 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53555 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53557 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53558 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53560 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53563 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53564 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53566 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53568 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53570 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53571 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53573 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53574 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53577 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53579 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53581 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53583 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53586 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53588 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53589 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53590 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53591 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53592 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53593 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53594 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53596 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53599 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53601 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53602 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53606 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53610 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53611 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53613 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53617 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53619 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53621 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53622 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53623 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53624 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53628 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53629 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53630 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53631 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53633 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53634 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53639 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53640 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53641 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53642 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53643 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53645 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53647 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53649 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53650 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53652 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53654 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53657 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53658 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53659 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53661 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53662 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53663 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53677 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53678 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53679 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53680 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53681 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53682 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53684 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53688 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53689 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53693 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53694 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53696 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53697 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53699 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53701 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53702 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53704 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53705 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53706 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53712 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53713 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53714 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53715 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53716 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53717 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53724 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53726 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53727 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53728 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53729 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53730 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53731 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53733 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53737 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53738 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53739 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53740 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53741 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53742 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53743 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53745 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53746 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53747 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53753 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53754 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53755 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53757 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53758 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53759 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53765 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53766 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53767 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53768 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53769 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53773 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53774 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53779 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53780 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53782 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53783 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53788 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53790 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53791 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53792 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53793 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53794 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53799 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53800 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53809 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53810 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53811 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53812 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53815 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53817 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53818 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53819 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53820 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53822 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53827 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53828 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53829 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53830 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53831 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53832 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53833 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53834 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53835 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53836 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53837 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53839 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53840 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53841 { NULL, NULL, 0, NULL }
53842 };
53843
53844
53845 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53846
53847 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53848 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53849 }
53850 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53851 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53852 }
53853 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53854 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53855 }
53856 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53857 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53858 }
53859 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53860 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53861 }
53862 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53863 return (void *)((wxSizer *) ((wxGridSizer *) x));
53864 }
53865 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53866 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53867 }
53868 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53869 return (void *)((wxSizer *) ((wxPySizer *) x));
53870 }
53871 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53872 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53873 }
53874 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53875 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53876 }
53877 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53878 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53879 }
53880 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53881 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53882 }
53883 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53884 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53885 }
53886 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53887 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53888 }
53889 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53890 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53891 }
53892 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53893 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53894 }
53895 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53896 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53897 }
53898 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53899 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53900 }
53901 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53902 return (void *)((wxEvent *) ((wxPyEvent *) x));
53903 }
53904 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53905 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53906 }
53907 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53908 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53909 }
53910 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53911 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53912 }
53913 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53914 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53915 }
53916 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53917 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53918 }
53919 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53920 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53921 }
53922 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53923 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53924 }
53925 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53926 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53927 }
53928 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53929 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53930 }
53931 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53932 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53933 }
53934 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53935 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53936 }
53937 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53938 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53939 }
53940 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53941 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53942 }
53943 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53944 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53945 }
53946 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53947 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53948 }
53949 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53950 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53951 }
53952 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53953 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53954 }
53955 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53956 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53957 }
53958 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53959 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53960 }
53961 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53962 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53963 }
53964 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53965 return (void *)((wxEvent *) ((wxShowEvent *) x));
53966 }
53967 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53968 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53969 }
53970 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53971 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53972 }
53973 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53974 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53975 }
53976 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53977 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53978 }
53979 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53980 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53981 }
53982 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53983 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53984 }
53985 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53986 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53987 }
53988 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53989 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53990 }
53991 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53992 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53993 }
53994 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53995 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53996 }
53997 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53998 return (void *)((wxControl *) ((wxControlWithItems *) x));
53999 }
54000 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54001 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54002 }
54003 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54004 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54005 }
54006 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54007 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54008 }
54009 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54010 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54011 }
54012 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54013 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54014 }
54015 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54016 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54017 }
54018 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54019 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54020 }
54021 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54022 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54023 }
54024 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54025 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54026 }
54027 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54028 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54029 }
54030 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54031 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54032 }
54033 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54034 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54035 }
54036 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54037 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54038 }
54039 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54040 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54041 }
54042 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54043 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54044 }
54045 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54046 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54047 }
54048 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54049 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54050 }
54051 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54052 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54053 }
54054 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54055 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54056 }
54057 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54058 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54059 }
54060 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54061 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54062 }
54063 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54064 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54065 }
54066 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54067 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54068 }
54069 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54070 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54071 }
54072 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54073 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54074 }
54075 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54076 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54077 }
54078 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54079 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54080 }
54081 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54082 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54083 }
54084 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54085 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54086 }
54087 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54088 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54089 }
54090 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54091 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54092 }
54093 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54094 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54095 }
54096 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54097 return (void *)((wxObject *) ((wxSizerItem *) x));
54098 }
54099 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54100 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54101 }
54102 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54103 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54104 }
54105 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54106 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54107 }
54108 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54109 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54110 }
54111 static void *_p_wxSizerTo_p_wxObject(void *x) {
54112 return (void *)((wxObject *) ((wxSizer *) x));
54113 }
54114 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54115 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54116 }
54117 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54118 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54119 }
54120 static void *_p_wxEventTo_p_wxObject(void *x) {
54121 return (void *)((wxObject *) ((wxEvent *) x));
54122 }
54123 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54124 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54125 }
54126 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54127 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54128 }
54129 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54130 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54131 }
54132 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54133 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54134 }
54135 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54136 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54137 }
54138 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54139 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54140 }
54141 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54142 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54143 }
54144 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54145 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54146 }
54147 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54148 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54149 }
54150 static void *_p_wxControlTo_p_wxObject(void *x) {
54151 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54152 }
54153 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54154 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54155 }
54156 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54157 return (void *)((wxObject *) ((wxFSFile *) x));
54158 }
54159 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54160 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54161 }
54162 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54163 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54164 }
54165 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54166 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54167 }
54168 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54170 }
54171 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) ((wxMenuItem *) x));
54173 }
54174 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54176 }
54177 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54179 }
54180 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54182 }
54183 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54185 }
54186 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54188 }
54189 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54191 }
54192 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54194 }
54195 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54197 }
54198 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54200 }
54201 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54203 }
54204 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54206 }
54207 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54209 }
54210 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54212 }
54213 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54215 }
54216 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54218 }
54219 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54221 }
54222 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54224 }
54225 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54227 }
54228 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54230 }
54231 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) ((wxImageHandler *) x));
54233 }
54234 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54236 }
54237 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54239 }
54240 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) ((wxEvtHandler *) x));
54242 }
54243 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54245 }
54246 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54248 }
54249 static void *_p_wxImageTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) ((wxImage *) x));
54251 }
54252 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54254 }
54255 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54257 }
54258 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54260 }
54261 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54263 }
54264 static void *_p_wxWindowTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54266 }
54267 static void *_p_wxMenuTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54269 }
54270 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54272 }
54273 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) ((wxFileSystem *) x));
54275 }
54276 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54277 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54278 }
54279 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54280 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54281 }
54282 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54283 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54284 }
54285 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54286 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54287 }
54288 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54289 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54290 }
54291 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54292 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54293 }
54294 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54295 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54296 }
54297 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54298 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54299 }
54300 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54301 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54302 }
54303 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54304 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54305 }
54306 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54307 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54308 }
54309 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54310 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54311 }
54312 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54313 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54314 }
54315 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54316 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54317 }
54318 static void *_p_wxControlTo_p_wxWindow(void *x) {
54319 return (void *)((wxWindow *) ((wxControl *) x));
54320 }
54321 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54322 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54323 }
54324 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54325 return (void *)((wxWindow *) ((wxMenuBar *) x));
54326 }
54327 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54328 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54329 }
54330 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54331 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54332 }
54333 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54334 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54335 }
54336 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54337 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54338 }
54339 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54340 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54341 }
54342 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54343 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54344 }
54345 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54346 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54347 }
54348 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54349 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54350 }
54351 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54352 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54353 }
54354 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54355 return (void *)((wxValidator *) ((wxPyValidator *) x));
54356 }
54357 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54359 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};
54360 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54471 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54472 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54473 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54474 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54475 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54476 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54477 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54478 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54479 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54480 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54481 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54482 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54483 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54484 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54485 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54486
54487 static swig_type_info *swig_type_initial[] = {
54488 &_swigt__p_buffer,
54489 &_swigt__p_char,
54490 &_swigt__p_form_ops_t,
54491 &_swigt__p_int,
54492 &_swigt__p_long,
54493 &_swigt__p_unsigned_char,
54494 &_swigt__p_unsigned_int,
54495 &_swigt__p_unsigned_long,
54496 &_swigt__p_wxANIHandler,
54497 &_swigt__p_wxAcceleratorEntry,
54498 &_swigt__p_wxAcceleratorTable,
54499 &_swigt__p_wxActivateEvent,
54500 &_swigt__p_wxAppTraits,
54501 &_swigt__p_wxArrayString,
54502 &_swigt__p_wxBMPHandler,
54503 &_swigt__p_wxBitmap,
54504 &_swigt__p_wxBoxSizer,
54505 &_swigt__p_wxButton,
54506 &_swigt__p_wxCURHandler,
54507 &_swigt__p_wxCaret,
54508 &_swigt__p_wxChildFocusEvent,
54509 &_swigt__p_wxCloseEvent,
54510 &_swigt__p_wxColour,
54511 &_swigt__p_wxCommandEvent,
54512 &_swigt__p_wxContextMenuEvent,
54513 &_swigt__p_wxControl,
54514 &_swigt__p_wxControlWithItems,
54515 &_swigt__p_wxCursor,
54516 &_swigt__p_wxDC,
54517 &_swigt__p_wxDateEvent,
54518 &_swigt__p_wxDateTime,
54519 &_swigt__p_wxDisplayChangedEvent,
54520 &_swigt__p_wxDropFilesEvent,
54521 &_swigt__p_wxDuplexMode,
54522 &_swigt__p_wxEraseEvent,
54523 &_swigt__p_wxEvent,
54524 &_swigt__p_wxEventLoop,
54525 &_swigt__p_wxEventLoopActivator,
54526 &_swigt__p_wxEvtHandler,
54527 &_swigt__p_wxFSFile,
54528 &_swigt__p_wxFileSystem,
54529 &_swigt__p_wxFileSystemHandler,
54530 &_swigt__p_wxFlexGridSizer,
54531 &_swigt__p_wxFocusEvent,
54532 &_swigt__p_wxFont,
54533 &_swigt__p_wxFrame,
54534 &_swigt__p_wxGBPosition,
54535 &_swigt__p_wxGBSizerItem,
54536 &_swigt__p_wxGBSpan,
54537 &_swigt__p_wxGIFHandler,
54538 &_swigt__p_wxGridBagSizer,
54539 &_swigt__p_wxGridSizer,
54540 &_swigt__p_wxICOHandler,
54541 &_swigt__p_wxIconizeEvent,
54542 &_swigt__p_wxIdleEvent,
54543 &_swigt__p_wxImage,
54544 &_swigt__p_wxImageHandler,
54545 &_swigt__p_wxImageHistogram,
54546 &_swigt__p_wxImage_HSVValue,
54547 &_swigt__p_wxImage_RGBValue,
54548 &_swigt__p_wxIndividualLayoutConstraint,
54549 &_swigt__p_wxInitDialogEvent,
54550 &_swigt__p_wxInputStream,
54551 &_swigt__p_wxInternetFSHandler,
54552 &_swigt__p_wxItemContainer,
54553 &_swigt__p_wxJPEGHandler,
54554 &_swigt__p_wxKeyEvent,
54555 &_swigt__p_wxLayoutConstraints,
54556 &_swigt__p_wxMaximizeEvent,
54557 &_swigt__p_wxMemoryFSHandler,
54558 &_swigt__p_wxMenu,
54559 &_swigt__p_wxMenuBar,
54560 &_swigt__p_wxMenuBarBase,
54561 &_swigt__p_wxMenuEvent,
54562 &_swigt__p_wxMenuItem,
54563 &_swigt__p_wxMouseCaptureChangedEvent,
54564 &_swigt__p_wxMouseEvent,
54565 &_swigt__p_wxMoveEvent,
54566 &_swigt__p_wxNavigationKeyEvent,
54567 &_swigt__p_wxNcPaintEvent,
54568 &_swigt__p_wxNotifyEvent,
54569 &_swigt__p_wxObject,
54570 &_swigt__p_wxOutputStream,
54571 &_swigt__p_wxPCXHandler,
54572 &_swigt__p_wxPNGHandler,
54573 &_swigt__p_wxPNMHandler,
54574 &_swigt__p_wxPaintEvent,
54575 &_swigt__p_wxPaletteChangedEvent,
54576 &_swigt__p_wxPaperSize,
54577 &_swigt__p_wxPoint,
54578 &_swigt__p_wxPoint2D,
54579 &_swigt__p_wxPropagateOnce,
54580 &_swigt__p_wxPropagationDisabler,
54581 &_swigt__p_wxPyApp,
54582 &_swigt__p_wxPyCommandEvent,
54583 &_swigt__p_wxPyDropTarget,
54584 &_swigt__p_wxPyEvent,
54585 &_swigt__p_wxPyFileSystemHandler,
54586 &_swigt__p_wxPyImageHandler,
54587 &_swigt__p_wxPyInputStream,
54588 &_swigt__p_wxPySizer,
54589 &_swigt__p_wxPyValidator,
54590 &_swigt__p_wxQuantize,
54591 &_swigt__p_wxQueryNewPaletteEvent,
54592 &_swigt__p_wxRealPoint,
54593 &_swigt__p_wxRect,
54594 &_swigt__p_wxRegion,
54595 &_swigt__p_wxScrollEvent,
54596 &_swigt__p_wxScrollWinEvent,
54597 &_swigt__p_wxSetCursorEvent,
54598 &_swigt__p_wxShowEvent,
54599 &_swigt__p_wxSize,
54600 &_swigt__p_wxSizeEvent,
54601 &_swigt__p_wxSizer,
54602 &_swigt__p_wxSizerItem,
54603 &_swigt__p_wxStaticBox,
54604 &_swigt__p_wxStaticBoxSizer,
54605 &_swigt__p_wxStdDialogButtonSizer,
54606 &_swigt__p_wxSysColourChangedEvent,
54607 &_swigt__p_wxTIFFHandler,
54608 &_swigt__p_wxToolTip,
54609 &_swigt__p_wxUpdateUIEvent,
54610 &_swigt__p_wxValidator,
54611 &_swigt__p_wxVisualAttributes,
54612 &_swigt__p_wxWindow,
54613 &_swigt__p_wxWindowCreateEvent,
54614 &_swigt__p_wxWindowDestroyEvent,
54615 &_swigt__p_wxXPMHandler,
54616 &_swigt__p_wxZipFSHandler,
54617 };
54618
54619 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54620 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54621 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54622 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54628 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54629 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54630 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54633 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}};
54634 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54635 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}};
54636 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54637 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}};
54638 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54639 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54640 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54641 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54642 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
54643 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54644 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}};
54645 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54646 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54657 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}};
54658 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54659 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54660 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}};
54661 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}};
54662 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54663 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54664 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54665 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54670 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}};
54671 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}};
54672 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54674 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54675 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}};
54676 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54683 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}};
54684 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54685 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54686 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54687 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54688 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54689 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54690 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54691 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54692 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54693 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54694 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54702 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54709 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54710 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54711 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54712 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54713 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54714 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54715 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54716 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54717 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54718 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54719 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54720 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54721 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54722 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54723 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54726 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54727 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54728 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54729 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54732 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}};
54733 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}};
54734 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54735 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54736 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54737 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54738 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54739 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54740 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54741 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}};
54742 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54743 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}};
54744 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54745 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54746 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54747 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54748
54749 static swig_cast_info *swig_cast_initial[] = {
54750 _swigc__p_buffer,
54751 _swigc__p_char,
54752 _swigc__p_form_ops_t,
54753 _swigc__p_int,
54754 _swigc__p_long,
54755 _swigc__p_unsigned_char,
54756 _swigc__p_unsigned_int,
54757 _swigc__p_unsigned_long,
54758 _swigc__p_wxANIHandler,
54759 _swigc__p_wxAcceleratorEntry,
54760 _swigc__p_wxAcceleratorTable,
54761 _swigc__p_wxActivateEvent,
54762 _swigc__p_wxAppTraits,
54763 _swigc__p_wxArrayString,
54764 _swigc__p_wxBMPHandler,
54765 _swigc__p_wxBitmap,
54766 _swigc__p_wxBoxSizer,
54767 _swigc__p_wxButton,
54768 _swigc__p_wxCURHandler,
54769 _swigc__p_wxCaret,
54770 _swigc__p_wxChildFocusEvent,
54771 _swigc__p_wxCloseEvent,
54772 _swigc__p_wxColour,
54773 _swigc__p_wxCommandEvent,
54774 _swigc__p_wxContextMenuEvent,
54775 _swigc__p_wxControl,
54776 _swigc__p_wxControlWithItems,
54777 _swigc__p_wxCursor,
54778 _swigc__p_wxDC,
54779 _swigc__p_wxDateEvent,
54780 _swigc__p_wxDateTime,
54781 _swigc__p_wxDisplayChangedEvent,
54782 _swigc__p_wxDropFilesEvent,
54783 _swigc__p_wxDuplexMode,
54784 _swigc__p_wxEraseEvent,
54785 _swigc__p_wxEvent,
54786 _swigc__p_wxEventLoop,
54787 _swigc__p_wxEventLoopActivator,
54788 _swigc__p_wxEvtHandler,
54789 _swigc__p_wxFSFile,
54790 _swigc__p_wxFileSystem,
54791 _swigc__p_wxFileSystemHandler,
54792 _swigc__p_wxFlexGridSizer,
54793 _swigc__p_wxFocusEvent,
54794 _swigc__p_wxFont,
54795 _swigc__p_wxFrame,
54796 _swigc__p_wxGBPosition,
54797 _swigc__p_wxGBSizerItem,
54798 _swigc__p_wxGBSpan,
54799 _swigc__p_wxGIFHandler,
54800 _swigc__p_wxGridBagSizer,
54801 _swigc__p_wxGridSizer,
54802 _swigc__p_wxICOHandler,
54803 _swigc__p_wxIconizeEvent,
54804 _swigc__p_wxIdleEvent,
54805 _swigc__p_wxImage,
54806 _swigc__p_wxImageHandler,
54807 _swigc__p_wxImageHistogram,
54808 _swigc__p_wxImage_HSVValue,
54809 _swigc__p_wxImage_RGBValue,
54810 _swigc__p_wxIndividualLayoutConstraint,
54811 _swigc__p_wxInitDialogEvent,
54812 _swigc__p_wxInputStream,
54813 _swigc__p_wxInternetFSHandler,
54814 _swigc__p_wxItemContainer,
54815 _swigc__p_wxJPEGHandler,
54816 _swigc__p_wxKeyEvent,
54817 _swigc__p_wxLayoutConstraints,
54818 _swigc__p_wxMaximizeEvent,
54819 _swigc__p_wxMemoryFSHandler,
54820 _swigc__p_wxMenu,
54821 _swigc__p_wxMenuBar,
54822 _swigc__p_wxMenuBarBase,
54823 _swigc__p_wxMenuEvent,
54824 _swigc__p_wxMenuItem,
54825 _swigc__p_wxMouseCaptureChangedEvent,
54826 _swigc__p_wxMouseEvent,
54827 _swigc__p_wxMoveEvent,
54828 _swigc__p_wxNavigationKeyEvent,
54829 _swigc__p_wxNcPaintEvent,
54830 _swigc__p_wxNotifyEvent,
54831 _swigc__p_wxObject,
54832 _swigc__p_wxOutputStream,
54833 _swigc__p_wxPCXHandler,
54834 _swigc__p_wxPNGHandler,
54835 _swigc__p_wxPNMHandler,
54836 _swigc__p_wxPaintEvent,
54837 _swigc__p_wxPaletteChangedEvent,
54838 _swigc__p_wxPaperSize,
54839 _swigc__p_wxPoint,
54840 _swigc__p_wxPoint2D,
54841 _swigc__p_wxPropagateOnce,
54842 _swigc__p_wxPropagationDisabler,
54843 _swigc__p_wxPyApp,
54844 _swigc__p_wxPyCommandEvent,
54845 _swigc__p_wxPyDropTarget,
54846 _swigc__p_wxPyEvent,
54847 _swigc__p_wxPyFileSystemHandler,
54848 _swigc__p_wxPyImageHandler,
54849 _swigc__p_wxPyInputStream,
54850 _swigc__p_wxPySizer,
54851 _swigc__p_wxPyValidator,
54852 _swigc__p_wxQuantize,
54853 _swigc__p_wxQueryNewPaletteEvent,
54854 _swigc__p_wxRealPoint,
54855 _swigc__p_wxRect,
54856 _swigc__p_wxRegion,
54857 _swigc__p_wxScrollEvent,
54858 _swigc__p_wxScrollWinEvent,
54859 _swigc__p_wxSetCursorEvent,
54860 _swigc__p_wxShowEvent,
54861 _swigc__p_wxSize,
54862 _swigc__p_wxSizeEvent,
54863 _swigc__p_wxSizer,
54864 _swigc__p_wxSizerItem,
54865 _swigc__p_wxStaticBox,
54866 _swigc__p_wxStaticBoxSizer,
54867 _swigc__p_wxStdDialogButtonSizer,
54868 _swigc__p_wxSysColourChangedEvent,
54869 _swigc__p_wxTIFFHandler,
54870 _swigc__p_wxToolTip,
54871 _swigc__p_wxUpdateUIEvent,
54872 _swigc__p_wxValidator,
54873 _swigc__p_wxVisualAttributes,
54874 _swigc__p_wxWindow,
54875 _swigc__p_wxWindowCreateEvent,
54876 _swigc__p_wxWindowDestroyEvent,
54877 _swigc__p_wxXPMHandler,
54878 _swigc__p_wxZipFSHandler,
54879 };
54880
54881
54882 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54883
54884 static swig_const_info swig_const_table[] = {
54885 {0, 0, 0, 0.0, 0, 0}};
54886
54887 #ifdef __cplusplus
54888 }
54889 #endif
54890 /* -----------------------------------------------------------------------------
54891 * Type initialization:
54892 * This problem is tough by the requirement that no dynamic
54893 * memory is used. Also, since swig_type_info structures store pointers to
54894 * swig_cast_info structures and swig_cast_info structures store pointers back
54895 * to swig_type_info structures, we need some lookup code at initialization.
54896 * The idea is that swig generates all the structures that are needed.
54897 * The runtime then collects these partially filled structures.
54898 * The SWIG_InitializeModule function takes these initial arrays out of
54899 * swig_module, and does all the lookup, filling in the swig_module.types
54900 * array with the correct data and linking the correct swig_cast_info
54901 * structures together.
54902 *
54903 * The generated swig_type_info structures are assigned staticly to an initial
54904 * array. We just loop though that array, and handle each type individually.
54905 * First we lookup if this type has been already loaded, and if so, use the
54906 * loaded structure instead of the generated one. Then we have to fill in the
54907 * cast linked list. The cast data is initially stored in something like a
54908 * two-dimensional array. Each row corresponds to a type (there are the same
54909 * number of rows as there are in the swig_type_initial array). Each entry in
54910 * a column is one of the swig_cast_info structures for that type.
54911 * The cast_initial array is actually an array of arrays, because each row has
54912 * a variable number of columns. So to actually build the cast linked list,
54913 * we find the array of casts associated with the type, and loop through it
54914 * adding the casts to the list. The one last trick we need to do is making
54915 * sure the type pointer in the swig_cast_info struct is correct.
54916 *
54917 * First off, we lookup the cast->type name to see if it is already loaded.
54918 * There are three cases to handle:
54919 * 1) If the cast->type has already been loaded AND the type we are adding
54920 * casting info to has not been loaded (it is in this module), THEN we
54921 * replace the cast->type pointer with the type pointer that has already
54922 * been loaded.
54923 * 2) If BOTH types (the one we are adding casting info to, and the
54924 * cast->type) are loaded, THEN the cast info has already been loaded by
54925 * the previous module so we just ignore it.
54926 * 3) Finally, if cast->type has not already been loaded, then we add that
54927 * swig_cast_info to the linked list (because the cast->type) pointer will
54928 * be correct.
54929 * ----------------------------------------------------------------------------- */
54930
54931 #ifdef __cplusplus
54932 extern "C" {
54933 #if 0
54934 } /* c-mode */
54935 #endif
54936 #endif
54937
54938 #if 0
54939 #define SWIGRUNTIME_DEBUG
54940 #endif
54941
54942 SWIGRUNTIME void
54943 SWIG_InitializeModule(void *clientdata) {
54944 size_t i;
54945 swig_module_info *module_head;
54946 static int init_run = 0;
54947
54948 clientdata = clientdata;
54949
54950 if (init_run) return;
54951 init_run = 1;
54952
54953 /* Initialize the swig_module */
54954 swig_module.type_initial = swig_type_initial;
54955 swig_module.cast_initial = swig_cast_initial;
54956
54957 /* Try and load any already created modules */
54958 module_head = SWIG_GetModule(clientdata);
54959 if (module_head) {
54960 swig_module.next = module_head->next;
54961 module_head->next = &swig_module;
54962 } else {
54963 /* This is the first module loaded */
54964 swig_module.next = &swig_module;
54965 SWIG_SetModule(clientdata, &swig_module);
54966 }
54967
54968 /* Now work on filling in swig_module.types */
54969 #ifdef SWIGRUNTIME_DEBUG
54970 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54971 #endif
54972 for (i = 0; i < swig_module.size; ++i) {
54973 swig_type_info *type = 0;
54974 swig_type_info *ret;
54975 swig_cast_info *cast;
54976
54977 #ifdef SWIGRUNTIME_DEBUG
54978 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54979 #endif
54980
54981 /* if there is another module already loaded */
54982 if (swig_module.next != &swig_module) {
54983 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54984 }
54985 if (type) {
54986 /* Overwrite clientdata field */
54987 #ifdef SWIGRUNTIME_DEBUG
54988 printf("SWIG_InitializeModule: found type %s\n", type->name);
54989 #endif
54990 if (swig_module.type_initial[i]->clientdata) {
54991 type->clientdata = swig_module.type_initial[i]->clientdata;
54992 #ifdef SWIGRUNTIME_DEBUG
54993 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54994 #endif
54995 }
54996 } else {
54997 type = swig_module.type_initial[i];
54998 }
54999
55000 /* Insert casting types */
55001 cast = swig_module.cast_initial[i];
55002 while (cast->type) {
55003 /* Don't need to add information already in the list */
55004 ret = 0;
55005 #ifdef SWIGRUNTIME_DEBUG
55006 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55007 #endif
55008 if (swig_module.next != &swig_module) {
55009 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55010 #ifdef SWIGRUNTIME_DEBUG
55011 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55012 #endif
55013 }
55014 if (ret) {
55015 if (type == swig_module.type_initial[i]) {
55016 #ifdef SWIGRUNTIME_DEBUG
55017 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55018 #endif
55019 cast->type = ret;
55020 ret = 0;
55021 } else {
55022 /* Check for casting already in the list */
55023 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55024 #ifdef SWIGRUNTIME_DEBUG
55025 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55026 #endif
55027 if (!ocast) ret = 0;
55028 }
55029 }
55030
55031 if (!ret) {
55032 #ifdef SWIGRUNTIME_DEBUG
55033 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55034 #endif
55035 if (type->cast) {
55036 type->cast->prev = cast;
55037 cast->next = type->cast;
55038 }
55039 type->cast = cast;
55040 }
55041 cast++;
55042 }
55043 /* Set entry in modules->types array equal to the type */
55044 swig_module.types[i] = type;
55045 }
55046 swig_module.types[i] = 0;
55047
55048 #ifdef SWIGRUNTIME_DEBUG
55049 printf("**** SWIG_InitializeModule: Cast List ******\n");
55050 for (i = 0; i < swig_module.size; ++i) {
55051 int j = 0;
55052 swig_cast_info *cast = swig_module.cast_initial[i];
55053 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55054 while (cast->type) {
55055 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55056 cast++;
55057 ++j;
55058 }
55059 printf("---- Total casts: %d\n",j);
55060 }
55061 printf("**** SWIG_InitializeModule: Cast List ******\n");
55062 #endif
55063 }
55064
55065 /* This function will propagate the clientdata field of type to
55066 * any new swig_type_info structures that have been added into the list
55067 * of equivalent types. It is like calling
55068 * SWIG_TypeClientData(type, clientdata) a second time.
55069 */
55070 SWIGRUNTIME void
55071 SWIG_PropagateClientData(void) {
55072 size_t i;
55073 swig_cast_info *equiv;
55074 static int init_run = 0;
55075
55076 if (init_run) return;
55077 init_run = 1;
55078
55079 for (i = 0; i < swig_module.size; i++) {
55080 if (swig_module.types[i]->clientdata) {
55081 equiv = swig_module.types[i]->cast;
55082 while (equiv) {
55083 if (!equiv->converter) {
55084 if (equiv->type && !equiv->type->clientdata)
55085 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55086 }
55087 equiv = equiv->next;
55088 }
55089 }
55090 }
55091 }
55092
55093 #ifdef __cplusplus
55094 #if 0
55095 {
55096 /* c-mode */
55097 #endif
55098 }
55099 #endif
55100
55101
55102
55103 #ifdef __cplusplus
55104 extern "C" {
55105 #endif
55106
55107 /* Python-specific SWIG API */
55108 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55109 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55110 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55111
55112 /* -----------------------------------------------------------------------------
55113 * global variable support code.
55114 * ----------------------------------------------------------------------------- */
55115
55116 typedef struct swig_globalvar {
55117 char *name; /* Name of global variable */
55118 PyObject *(*get_attr)(void); /* Return the current value */
55119 int (*set_attr)(PyObject *); /* Set the value */
55120 struct swig_globalvar *next;
55121 } swig_globalvar;
55122
55123 typedef struct swig_varlinkobject {
55124 PyObject_HEAD
55125 swig_globalvar *vars;
55126 } swig_varlinkobject;
55127
55128 SWIGINTERN PyObject *
55129 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55130 return PyString_FromString("<Swig global variables>");
55131 }
55132
55133 SWIGINTERN PyObject *
55134 swig_varlink_str(swig_varlinkobject *v) {
55135 PyObject *str = PyString_FromString("(");
55136 swig_globalvar *var;
55137 for (var = v->vars; var; var=var->next) {
55138 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55139 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55140 }
55141 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55142 return str;
55143 }
55144
55145 SWIGINTERN int
55146 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55147 PyObject *str = swig_varlink_str(v);
55148 fprintf(fp,"Swig global variables ");
55149 fprintf(fp,"%s\n", PyString_AsString(str));
55150 Py_DECREF(str);
55151 return 0;
55152 }
55153
55154 SWIGINTERN void
55155 swig_varlink_dealloc(swig_varlinkobject *v) {
55156 swig_globalvar *var = v->vars;
55157 while (var) {
55158 swig_globalvar *n = var->next;
55159 free(var->name);
55160 free(var);
55161 var = n;
55162 }
55163 }
55164
55165 SWIGINTERN PyObject *
55166 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55167 PyObject *res = NULL;
55168 swig_globalvar *var = v->vars;
55169 while (var) {
55170 if (strcmp(var->name,n) == 0) {
55171 res = (*var->get_attr)();
55172 break;
55173 }
55174 var = var->next;
55175 }
55176 if (res == NULL && !PyErr_Occurred()) {
55177 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55178 }
55179 return res;
55180 }
55181
55182 SWIGINTERN int
55183 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55184 int res = 1;
55185 swig_globalvar *var = v->vars;
55186 while (var) {
55187 if (strcmp(var->name,n) == 0) {
55188 res = (*var->set_attr)(p);
55189 break;
55190 }
55191 var = var->next;
55192 }
55193 if (res == 1 && !PyErr_Occurred()) {
55194 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55195 }
55196 return res;
55197 }
55198
55199 SWIGINTERN PyTypeObject*
55200 swig_varlink_type(void) {
55201 static char varlink__doc__[] = "Swig var link object";
55202 static PyTypeObject varlink_type;
55203 static int type_init = 0;
55204 if (!type_init) {
55205 const PyTypeObject tmp
55206 = {
55207 PyObject_HEAD_INIT(NULL)
55208 0, /* Number of items in variable part (ob_size) */
55209 (char *)"swigvarlink", /* Type name (tp_name) */
55210 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55211 0, /* Itemsize (tp_itemsize) */
55212 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55213 (printfunc) swig_varlink_print, /* Print (tp_print) */
55214 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55215 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55216 0, /* tp_compare */
55217 (reprfunc) swig_varlink_repr, /* tp_repr */
55218 0, /* tp_as_number */
55219 0, /* tp_as_sequence */
55220 0, /* tp_as_mapping */
55221 0, /* tp_hash */
55222 0, /* tp_call */
55223 (reprfunc)swig_varlink_str, /* tp_str */
55224 0, /* tp_getattro */
55225 0, /* tp_setattro */
55226 0, /* tp_as_buffer */
55227 0, /* tp_flags */
55228 varlink__doc__, /* tp_doc */
55229 0, /* tp_traverse */
55230 0, /* tp_clear */
55231 0, /* tp_richcompare */
55232 0, /* tp_weaklistoffset */
55233 #if PY_VERSION_HEX >= 0x02020000
55234 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55235 #endif
55236 #if PY_VERSION_HEX >= 0x02030000
55237 0, /* tp_del */
55238 #endif
55239 #ifdef COUNT_ALLOCS
55240 0,0,0,0 /* tp_alloc -> tp_next */
55241 #endif
55242 };
55243 varlink_type = tmp;
55244 varlink_type.ob_type = &PyType_Type;
55245 type_init = 1;
55246 }
55247 return &varlink_type;
55248 }
55249
55250 /* Create a variable linking object for use later */
55251 SWIGINTERN PyObject *
55252 SWIG_Python_newvarlink(void) {
55253 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55254 if (result) {
55255 result->vars = 0;
55256 }
55257 return ((PyObject*) result);
55258 }
55259
55260 SWIGINTERN void
55261 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55262 swig_varlinkobject *v = (swig_varlinkobject *) p;
55263 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55264 if (gv) {
55265 size_t size = strlen(name)+1;
55266 gv->name = (char *)malloc(size);
55267 if (gv->name) {
55268 strncpy(gv->name,name,size);
55269 gv->get_attr = get_attr;
55270 gv->set_attr = set_attr;
55271 gv->next = v->vars;
55272 }
55273 }
55274 v->vars = gv;
55275 }
55276
55277 SWIGINTERN PyObject *
55278 SWIG_globals() {
55279 static PyObject *_SWIG_globals = 0;
55280 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55281 return _SWIG_globals;
55282 }
55283
55284 /* -----------------------------------------------------------------------------
55285 * constants/methods manipulation
55286 * ----------------------------------------------------------------------------- */
55287
55288 /* Install Constants */
55289 SWIGINTERN void
55290 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55291 PyObject *obj = 0;
55292 size_t i;
55293 for (i = 0; constants[i].type; ++i) {
55294 switch(constants[i].type) {
55295 case SWIG_PY_POINTER:
55296 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55297 break;
55298 case SWIG_PY_BINARY:
55299 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55300 break;
55301 default:
55302 obj = 0;
55303 break;
55304 }
55305 if (obj) {
55306 PyDict_SetItemString(d, constants[i].name, obj);
55307 Py_DECREF(obj);
55308 }
55309 }
55310 }
55311
55312 /* -----------------------------------------------------------------------------*/
55313 /* Fix SwigMethods to carry the callback ptrs when needed */
55314 /* -----------------------------------------------------------------------------*/
55315
55316 SWIGINTERN void
55317 SWIG_Python_FixMethods(PyMethodDef *methods,
55318 swig_const_info *const_table,
55319 swig_type_info **types,
55320 swig_type_info **types_initial) {
55321 size_t i;
55322 for (i = 0; methods[i].ml_name; ++i) {
55323 char *c = methods[i].ml_doc;
55324 if (c && (c = strstr(c, "swig_ptr: "))) {
55325 int j;
55326 swig_const_info *ci = 0;
55327 char *name = c + 10;
55328 for (j = 0; const_table[j].type; ++j) {
55329 if (strncmp(const_table[j].name, name,
55330 strlen(const_table[j].name)) == 0) {
55331 ci = &(const_table[j]);
55332 break;
55333 }
55334 }
55335 if (ci) {
55336 size_t shift = (ci->ptype) - types;
55337 swig_type_info *ty = types_initial[shift];
55338 size_t ldoc = (c - methods[i].ml_doc);
55339 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55340 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55341 if (ndoc) {
55342 char *buff = ndoc;
55343 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55344 if (ptr) {
55345 strncpy(buff, methods[i].ml_doc, ldoc);
55346 buff += ldoc;
55347 strncpy(buff, "swig_ptr: ", 10);
55348 buff += 10;
55349 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55350 methods[i].ml_doc = ndoc;
55351 }
55352 }
55353 }
55354 }
55355 }
55356 }
55357
55358 #ifdef __cplusplus
55359 }
55360 #endif
55361
55362 /* -----------------------------------------------------------------------------*
55363 * Partial Init method
55364 * -----------------------------------------------------------------------------*/
55365
55366 #ifdef __cplusplus
55367 extern "C"
55368 #endif
55369 SWIGEXPORT void SWIG_init(void) {
55370 PyObject *m, *d;
55371
55372 /* Fix SwigMethods to carry the callback ptrs when needed */
55373 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55374
55375 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55376 d = PyModule_GetDict(m);
55377
55378 SWIG_InitializeModule(0);
55379 SWIG_InstallConstants(d,swig_const_table);
55380
55381
55382
55383 #ifndef wxPyUSE_EXPORT
55384 // Make our API structure a CObject so other modules can import it
55385 // from this module.
55386 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55387 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55388 Py_XDECREF(cobj);
55389 #endif
55390
55391 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55392 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55393 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55394 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55395 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55396 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55397 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55398 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55399 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55400 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55401 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55402 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55403 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55404 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55405 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55406 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55407 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55408 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55409 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55410 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55411 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55412 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55413 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55414 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55415 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55416 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55417 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55418 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55419 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55420 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55421 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55422 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55423 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55424 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55425 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55426 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55427 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55428 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55429 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55430 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55431 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55432 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55433 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55434 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55435 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55436 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55437 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55438 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55439 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55440 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55441 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55442 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55443 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55444 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55445 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55446 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55447 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55448 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55449 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55450 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55451 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55452 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55453 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55454 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55455 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55456 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55457 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55458 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55459 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55460 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55461 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55462 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55463 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55464 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55465 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55466 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55467 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55468 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55469 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55470 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55471 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55472 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55473 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55474 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55475 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55476 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55477 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55478 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55479 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55480 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55481 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55482 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55483 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55484 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55485 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55486 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55487 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55488 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55489 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55490 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55491 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55492 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55493 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55494 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55495 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55496 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55497 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55498 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55499 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55500 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55501 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55502 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55503 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55504 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55505 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55506 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55507 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55508 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55509 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55510 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55511 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55512 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55513 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55514 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55515 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55516 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55517 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55518 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55519 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55520 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55521 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55522 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55523 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55524 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55525 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55526 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55527 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55528 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55529 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55530 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55531 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55532 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55533 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55534 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55535 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55536 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55537 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55538 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55539 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55540 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55541 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55542 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55543 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55544 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55545 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55546 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55547 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55548 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55549 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55550 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55551 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55552 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55553 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55554 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55555 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55556 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55557 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55558 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55559 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55560 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55561 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55562 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55563 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55564 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55565 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55566 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55567 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55568 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55569 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55570 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55571 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55572 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55573 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55574 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55575 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55576 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55577 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55578 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55579 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55580 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55581 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55582 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55583 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55584 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55585 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55586 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55587 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55588 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55589 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55590 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55591 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55592 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55593 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55594 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55595 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55596 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55597 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55598 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55599 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55600 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55601 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55602 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55603 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55604 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55605 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55606 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55607 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55608 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55609 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55610 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55611 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55612 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55613 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55614 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55615 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55616 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55617 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55618 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55619 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55620 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55621 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55622 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55623 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55624 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55625 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55626 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55627 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55628 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55629 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55630 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55631 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55632 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55633 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55634 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55635 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55636 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55637 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55638 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55639 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55640 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55641 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55642 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55643 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55644 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55645 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55646 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55647 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55648 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55649 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55650 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55651 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55652 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55653 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55654 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55655 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55656 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55657 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55658 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55659 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55660 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55661 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55662 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55663 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55664 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55665 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55666 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55667 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55668 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55669 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55670 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55671 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55672 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55673 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55674 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55675 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55676 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55677 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55678 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55679 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55680 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55681 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55682 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55683 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55684 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55685 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55686 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55687 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55688 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55689 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55690 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55691 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55692 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55693 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55694 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55695 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55696 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55697 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55698 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55699 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55700 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55701 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55702 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55703 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55704 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55705 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55706 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55707 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55708 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55709 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55710 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55711 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55712 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55713 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55714 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55715 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55716 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55717 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55718 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55719 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55720 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55721 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55722 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55723 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55724 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55725 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55726 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55727 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55728 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55729 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55730 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55731 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55732 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55733 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55734 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55735 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55736 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55737 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55738 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55739 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55740 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55741 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55742 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55743 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55744 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55745 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55746 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55747 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55748 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55749 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55750 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55751 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55752 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55753 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55754 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55755 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55756 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55757 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55758 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55759 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55760 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55761 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55762 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55763 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55764 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55765 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55766 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55767 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55768 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55769 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55770 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55771 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55772 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55773 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55774 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55775 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55776 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55777 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55778 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55779 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55780 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55781 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55782 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55783 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55784 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55785 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55786 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55787 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55788 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55789 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55790 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55791 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55792 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55793 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55794 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55795 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55796 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55797 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55798 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55799 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55800 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55801 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55802 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55803 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55804 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55805 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55806 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55807 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55808 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55809 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55810 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55811 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55812 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55813 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55814 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55815 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55816 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55817 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55818 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55819 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55820 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55821 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55822 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55823 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55824 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55825 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55826 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55827 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55828 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55829 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55830 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55831 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55832 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55833 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55834 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55835 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55836 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55837 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55838 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55839 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55840 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55841 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55842 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55843 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55844 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55845 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55846 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55847 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55848 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55849 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55850 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55851 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55852 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55853 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55854 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55855 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55856 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55857 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55858 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55859 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55860 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55861 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55862 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55863 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55864 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55865 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55866 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55867 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55868 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55869 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55870 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55871 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55872 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55873 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55874 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55875 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55876 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55877 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55878 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55879 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55880 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55881 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55882 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55883 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55884 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55885 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55886 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55887 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55888 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55889 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55890 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55891 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55892 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55893 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55894 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55895 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55896 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55897 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55898 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55899 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55900 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55901 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55902 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55903 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55904 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55905 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55906 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55907 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55908 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55909 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55910 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55911 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55912 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55913 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55914 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55915 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55916 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55917 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55918 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55919 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55920 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55921 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55922 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55923 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55924 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55925 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55926 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55927 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55928 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55929 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55930 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55931 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55932 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55933 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55934 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55935 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55936 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55937 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55938 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55939 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55940 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55941 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55942 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55943 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55944 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55945 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55946 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55947 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55948 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55949 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55950 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55951 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55952 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55953 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55954 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55955 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55956 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55957 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55958 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55959 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55960 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55961 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55962 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55963 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55964 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55965 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55966 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55967 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55968 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55969 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55970 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55971 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55972 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55973 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55974 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55975 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55976 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55977 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55978 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55979 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55980 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55981 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55982 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55983 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55984 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55985 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55986 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55987 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55988 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55989 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55990 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55991 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55992 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55993 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55994 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55995 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55996 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55997 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55998 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55999 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56000 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56001 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56002 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56003 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56004 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56005 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56006 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56007 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56008 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56009 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56010 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56011 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56012 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56013 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56014 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56015 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56016 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56017 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56018 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56019 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56020 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56021 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56022 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56023 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56024 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56025 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56026 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56027 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56028 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56029 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56030 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56031 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56032 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56033 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56034 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56035 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56036 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56037 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56038 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56039 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56040 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56041 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56042 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56043 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56044 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56045 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56046 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56047 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56048 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56049 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56050 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56051 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56052 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56053 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56054 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56055 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56056 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56057 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56058 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56059 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56060 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56061 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56062
56063 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56064
56065
56066 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56067
56068 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56069 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56070 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56071 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56072 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56073 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56074 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56075 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56076 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56077 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56078 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56079 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56080 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56081 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56082 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56083 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56084 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56085 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56086 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56087 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56088 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56089 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56090 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56091 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56092 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56093 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56094 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56095 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56096 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56097 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56098 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56099 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56100 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56101 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56102 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56103 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56104 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56105 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56106 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56107 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56108 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56109 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56110 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56111 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56112 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56113 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56114 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56115 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56116 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56117 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56118 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56119 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56120 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56121 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56122 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56123 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56124 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56125 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56126 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56127 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56128 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56129 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56130 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56131 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56132 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56133 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56134 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56135 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56136 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56137 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56138 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56139 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56140 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56141 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56142 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56143 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56144 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56145 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56146 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56147 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56148 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56149 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56150 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56151 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56152 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56153 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56154 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56155 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56156 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56157 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56158 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56159 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56160 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56161 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56162 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56163 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56164 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56165 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56166 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56167 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56168 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56169 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56170 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56171 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56172 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56173 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56174 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56175 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56176 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56177 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56178 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56179 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56180 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56181 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56182 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56183 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56184 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56185 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56186 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56187 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56188 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56189 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56190 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56191 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56192 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56193 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56194 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56195 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56196 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56197 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56198 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56199 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56200 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56201 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56202 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56203 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56204 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56205 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56206 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56207 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56208 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56209 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56210 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56211 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56212 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56213 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56214 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56215 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56216 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56217 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56218 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56219 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56220 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56221 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56222 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56223 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56224 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56225 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56226 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56227 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56228 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56229 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56230 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56231 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56232 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56233 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56234 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56235 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56236 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56237 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56238 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56239 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56240 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56241 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56242 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56243 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56244 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56245 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56246 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56247 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56248 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56249 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56250 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56251 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56252 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56253 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56254 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56255 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56256 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56257 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56258 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56259 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56260 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56261 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56262 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56263 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56264 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56265 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56266 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56267 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56268 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56269 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56270 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56271 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56272
56273 // Initialize threading, some globals and such
56274 __wxPyPreStart(d);
56275
56276
56277 // Although these are defined in __version__ they need to be here too so
56278 // that an assert can be done to ensure that the wxPython and the wxWindows
56279 // versions match.
56280 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56281 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56282 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56283
56284 }
56285
wxWidgets (Impactor)